---

yaml
---
r: 151025
b: refs/heads/try2
c: f495723
h: refs/heads/master
i:
  151023: e1957bc
v: v3

Author: aochagavia

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 09bfb92fdc3ccff42dfcf91b0af368f88dc3e446
+refs/heads/try2: f49572373347b4110e7140fafbcb57db112712bd
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -33,7 +33,7 @@ pleasant high-level features include:
 This is an introductory tutorial for the Rust programming language. It
 covers the fundamentals of the language, including the syntax, the
 type system and memory model, generics, and modules. [Additional
-tutorials](#what-next?) cover specific language features in greater
+tutorials](#what-next) cover specific language features in greater
 depth.
 
 This tutorial assumes that the reader is already familiar with one or
@@ -2253,7 +2253,7 @@ defining one.
 
 The type parameters bound by a trait are in scope in each of the
 method declarations. So, re-declaring the type parameter
-`T` as an explicit type parameter for `len`, in either the trait or
+`T` as an explicit type parameter for `length`, in either the trait or
 the impl, would be a compile-time error.
 
 Within a trait definition, `Self` is a special type that you can think

branches/try2/src/libcollections/btree.rs

@@ -659,13 +659,13 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Branch<K, V> {
     }
 }
 
-//A LeafElt contains no left child, but a key-value pair.
+//A LeafElt containts no left child, but a key-value pair.
 struct LeafElt<K, V> {
     key: K,
     value: V
 }
 
-//A BranchElt has a left child in insertion to a key-value pair.
+//A BranchElt has a left child in insertition to a key-value pair.
 struct BranchElt<K, V> {
     left: ~Node<K, V>,
     key: K,

branches/try2/src/libcollections/hashmap.rs

@@ -605,7 +605,7 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
 //
 // > Why a load factor of 90%?
 //
-// In general, all the distances to initial buckets will converge on the mean.
+// In general, all the distances to inital buckets will converge on the mean.
 // At a load factor of α, the odds of finding the target bucket after k
 // probes is approximately 1-α^k. If we set this equal to 50% (since we converge
 // on the mean) and set k=8 (64-byte cache line / 8-byte hash), α=0.92. I round
@@ -618,7 +618,7 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
 // > Wait, what? Where did you get 1-α^k from?
 //
 // On the first probe, your odds of a collision with an existing element is α.
-// The odds of doing this twice in a row is approximately α^2. For three times,
+// The odds of doing this twice in a row is approximatelly α^2. For three times,
 // α^3, etc. Therefore, the odds of colliding k times is α^k. The odds of NOT
 // colliding after k tries is 1-α^k.
 //
@@ -692,7 +692,7 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
 /// let mut book_reviews = HashMap::new();
 ///
 /// // review some books.
-/// book_reviews.insert("Adventures of Huckleberry Finn",    "My favorite book.");
+/// book_reviews.insert("Adventures of Hucklebury Fin",      "My favorite book.");
 /// book_reviews.insert("Grimms' Fairy Tales",               "Masterpiece.");
 /// book_reviews.insert("Pride and Prejudice",               "Very enjoyable.");
 /// book_reviews.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
@@ -782,7 +782,7 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// from its 'ideal' location.
     ///
     /// In the cited blog posts above, this is called the "distance to
-    /// initial bucket", or DIB.
+    /// inital bucket", or DIB.
     fn bucket_distance(&self, index_of_elem: &table::FullIndex) -> uint {
         // where the hash of the element that happens to reside at
         // `index_of_elem` tried to place itself first.

branches/try2/src/libcollections/treemap.rs

@@ -308,7 +308,7 @@ pub struct RevMutEntries<'a, K, V> {
 // (with many different `x`) below, so we need to optionally pass mut
 // as a tt, but the only thing we can do with a `tt` is pass them to
 // other macros, so this takes the `& <mutability> <operand>` token
-// sequence and forces their evaluation as an expression.
+// sequence and forces their evalutation as an expression.
 macro_rules! addr { ($e:expr) => { $e }}
 // putting an optional mut into type signatures
 macro_rules! item { ($i:item) => { $i }}

branches/try2/src/libcollections/trie.rs

@@ -141,7 +141,7 @@ impl<T> TrieMap<T> {
 // (with many different `x`) below, so we need to optionally pass mut
 // as a tt, but the only thing we can do with a `tt` is pass them to
 // other macros, so this takes the `& <mutability> <operand>` token
-// sequence and forces their evaluation as an expression. (see also
+// sequence and forces their evalutation as an expression. (see also
 // `item!` below.)
 macro_rules! addr { ($e:expr) => { $e } }
 

branches/try2/src/libnum/lib.rs

@@ -171,7 +171,7 @@ macro_rules! impl_integer_for_int {
             /// `other`.
             #[inline]
             fn lcm(&self, other: &$T) -> $T {
-                // should not have to recalculate abs
+                // should not have to recaluculate abs
                 ((*self * *other) / self.gcd(other)).abs()
             }
 

branches/try2/src/librustc/back/link.rs

@@ -1171,7 +1171,7 @@ fn link_args(sess: &Session,
         // actually creates "invalid" objects [1] [2], but only for some
         // introspection tools, not in terms of whether it can be loaded.
         //
-        // Long story short, passing this flag forces the linker to *not*
+        // Long story shory, passing this flag forces the linker to *not*
         // truncate section names (so we can find the metadata section after
         // it's compiled). The real kicker is that rust compiled just fine on
         // windows for quite a long time *without* this flag, so I have no idea
@@ -1491,7 +1491,7 @@ fn add_upstream_rust_crates(args: &mut Vec<~str>, sess: &Session,
 }
 
 // Link in all of our upstream crates' native dependencies. Remember that
-// all of these upstream native dependencies are all non-static
+// all of these upstream native depenencies are all non-static
 // dependencies. We've got two cases then:
 //
 // 1. The upstream crate is an rlib. In this case we *must* link in the
@@ -1509,7 +1509,7 @@ fn add_upstream_rust_crates(args: &mut Vec<~str>, sess: &Session,
 // be instantiated in the target crate, meaning that the native symbol must
 // also be resolved in the target crate.
 fn add_upstream_native_libraries(args: &mut Vec<~str>, sess: &Session) {
-    // Be sure to use a topological sorting of crates because there may be
+    // Be sure to use a topological sorting of crates becuase there may be
     // interdependencies between native libraries. When passing -nodefaultlibs,
     // for example, almost all native libraries depend on libc, so we have to
     // make sure that's all the way at the right (liblibc is near the base of

branches/try2/src/librustc/back/svh.rs

@@ -20,7 +20,7 @@
 //! such.
 //!
 //! The core of this problem is when an upstream dependency changes and
-//! downstream dependents are not recompiled. This causes compile errors because
+//! downstream dependants are not recompiled. This causes compile errors because
 //! the upstream crate's metadata has changed but the downstream crates are
 //! still referencing the older crate's metadata.
 //!

branches/try2/src/librustc/driver/driver.rs

@@ -299,7 +299,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         last_private_map: last_private_map
     } =
         time(time_passes, "resolution", (), |_|
-             middle::resolve::resolve_crate(&sess, &lang_items, krate));
+             middle::resolve::resolve_crate(&sess, lang_items, krate));
 
     // Discard MTWT tables that aren't required past resolution.
     syntax::ext::mtwt::clear_tables();
@@ -316,7 +316,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                 sess.diagnostic(), krate)));
 
     let freevars = time(time_passes, "freevar finding", (), |_|
-                        freevars::annotate_freevars(&def_map, krate));
+                        freevars::annotate_freevars(def_map, krate));
 
     let region_map = time(time_passes, "region resolution", (), |_|
                           middle::region::resolve_crate(&sess, krate));
@@ -328,7 +328,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                             freevars, region_map, lang_items);
 
     // passes are timed inside typeck
-    typeck::check_crate(&ty_cx, trait_map, krate);
+    let (method_map, vtable_map) = typeck::check_crate(&ty_cx, trait_map, krate);
 
     time(time_passes, "check static items", (), |_|
          middle::check_static::check_crate(&ty_cx, krate));
@@ -338,52 +338,56 @@ pub fn phase_3_run_analysis_passes(sess: Session,
          middle::const_eval::process_crate(krate, &ty_cx));
 
     time(time_passes, "const checking", (), |_|
-         middle::check_const::check_crate(krate, &ty_cx));
+         middle::check_const::check_crate(krate, def_map, method_map, &ty_cx));
 
     let maps = (external_exports, last_private_map);
     let (exported_items, public_items) =
             time(time_passes, "privacy checking", maps, |(a, b)|
-                 middle::privacy::check_crate(&ty_cx, &exp_map2, a, b, krate));
+                 middle::privacy::check_crate(&ty_cx, &method_map, &exp_map2,
+                                              a, b, krate));
 
     time(time_passes, "effect checking", (), |_|
-         middle::effect::check_crate(&ty_cx, krate));
+         middle::effect::check_crate(&ty_cx, method_map, krate));
 
     let middle::moves::MoveMaps {moves_map, moved_variables_set,
                                  capture_map} =
         time(time_passes, "compute moves", (), |_|
-             middle::moves::compute_moves(&ty_cx, krate));
+             middle::moves::compute_moves(&ty_cx, method_map, krate));
 
     time(time_passes, "match checking", (), |_|
-         middle::check_match::check_crate(&ty_cx, &moves_map, krate));
+         middle::check_match::check_crate(&ty_cx, method_map,
+                                          &moves_map, krate));
 
     time(time_passes, "liveness checking", (), |_|
-         middle::liveness::check_crate(&ty_cx, &capture_map, krate));
+         middle::liveness::check_crate(&ty_cx, method_map,
+                                       &capture_map, krate));
 
     let root_map =
         time(time_passes, "borrow checking", (), |_|
-             middle::borrowck::check_crate(&ty_cx, &moves_map,
-                                           &moved_variables_set,
+             middle::borrowck::check_crate(&ty_cx, method_map,
+                                           &moves_map, &moved_variables_set,
                                            &capture_map, krate));
 
     drop(moves_map);
     drop(moved_variables_set);
 
     time(time_passes, "kind checking", (), |_|
-         kind::check_crate(&ty_cx, krate));
+         kind::check_crate(&ty_cx, method_map, krate));
 
     let reachable_map =
         time(time_passes, "reachability checking", (), |_|
-             reachable::find_reachable(&ty_cx, &exported_items));
+             reachable::find_reachable(&ty_cx, method_map, &exported_items));
 
     time(time_passes, "death checking", (), |_| {
         middle::dead::check_crate(&ty_cx,
+                                  method_map,
                                   &exported_items,
                                   &reachable_map,
                                   krate)
     });
 
     time(time_passes, "lint checking", (), |_|
-         lint::check_crate(&ty_cx, &exported_items, krate));
+         lint::check_crate(&ty_cx, method_map, &exported_items, krate));
 
     CrateAnalysis {
         exp_map2: exp_map2,
@@ -392,6 +396,8 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         public_items: public_items,
         maps: astencode::Maps {
             root_map: root_map,
+            method_map: method_map,
+            vtable_map: vtable_map,
             capture_map: RefCell::new(capture_map)
         },
         reachable: reachable_map

branches/try2/src/librustc/lib/llvm.rs

@@ -1882,23 +1882,37 @@ impl TypeNames {
 
 /* Memory-managed interface to target data. */
 
-pub struct TargetData {
-    pub lltd: TargetDataRef
+pub struct target_data_res {
+    pub td: TargetDataRef,
 }
 
-impl Drop for TargetData {
+impl Drop for target_data_res {
     fn drop(&mut self) {
         unsafe {
-            llvm::LLVMDisposeTargetData(self.lltd);
+            llvm::LLVMDisposeTargetData(self.td);
         }
     }
 }
 
+pub fn target_data_res(td: TargetDataRef) -> target_data_res {
+    target_data_res {
+        td: td
+    }
+}
+
+pub struct TargetData {
+    pub lltd: TargetDataRef,
+    dtor: @target_data_res
+}
+
 pub fn mk_target_data(string_rep: &str) -> TargetData {
+    let lltd = string_rep.with_c_str(|buf| {
+        unsafe { llvm::LLVMCreateTargetData(buf) }
+    });
+
     TargetData {
-        lltd: string_rep.with_c_str(|buf| {
-            unsafe { llvm::LLVMCreateTargetData(buf) }
-        })
+        lltd: lltd,
+        dtor: @target_data_res(lltd)
     }
 }
 
@@ -1935,22 +1949,35 @@ impl Drop for ObjectFile {
 
 /* Memory-managed interface to section iterators. */
 
-pub struct SectionIter {
-    pub llsi: SectionIteratorRef
+pub struct section_iter_res {
+    pub si: SectionIteratorRef,
 }
 
-impl Drop for SectionIter {
+impl Drop for section_iter_res {
     fn drop(&mut self) {
         unsafe {
-            llvm::LLVMDisposeSectionIterator(self.llsi);
+            llvm::LLVMDisposeSectionIterator(self.si);
         }
     }
 }
 
+pub fn section_iter_res(si: SectionIteratorRef) -> section_iter_res {
+    section_iter_res {
+        si: si
+    }
+}
+
+pub struct SectionIter {
+    pub llsi: SectionIteratorRef,
+    dtor: @section_iter_res
+}
+
 pub fn mk_section_iter(llof: ObjectFileRef) -> SectionIter {
     unsafe {
+        let llsi = llvm::LLVMGetSections(llof);
         SectionIter {
-            llsi: llvm::LLVMGetSections(llof)
+            llsi: llsi,
+            dtor: @section_iter_res(llsi)
         }
     }
 }