---

yaml
---
r: 41891
b: refs/heads/master
c: 7eb8642
h: refs/heads/master
i:
  41889: 6a08cb1
  41887: 214eefd
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9cdcd9bff930fd9fc0813418c63def0a06f2558a
+refs/heads/master: 7eb8642aed3cd12a836c75aff25cbaf2dfc35017
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/libcore/gc.rs

@@ -44,7 +44,7 @@ use io;
 use libc::{size_t, uintptr_t};
 use option::{None, Option, Some};
 use ptr;
-use send_map::linear::LinearSet;
+use send_map::linear::LinearMap;
 use stackwalk;
 use sys;
 
@@ -294,6 +294,12 @@ pub fn gc() {
     }
 }
 
+type RootSet = LinearMap<*Word,()>;
+
+fn RootSet() -> RootSet {
+    LinearMap()
+}
+
 #[cfg(gc)]
 fn expect_sentinel() -> bool { true }
 
@@ -331,13 +337,13 @@ pub fn cleanup_stack_for_failure() {
             ptr::null()
         };
 
-        let mut roots = LinearSet::new();
+        let mut roots = ~RootSet();
         for walk_gc_roots(need_cleanup, sentinel) |root, tydesc| {
             // Track roots to avoid double frees.
-            if roots.contains(&*root) {
+            if roots.find(&*root).is_some() {
                 loop;
             }
-            roots.insert(*root);
+            roots.insert(*root, ());
 
             if ptr::is_null(tydesc) {
                 // FIXME #4420: Destroy this box

trunk/src/libcore/send_map.rs

@@ -485,7 +485,7 @@ pub mod linear {
         fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
     }
 
-    pub impl <T: Hash IterBytes Eq> LinearSet<T> {
+    impl <T: Hash IterBytes Eq> LinearSet<T> {
         /// Create an empty LinearSet
         static fn new() -> LinearSet<T> { LinearSet{map: LinearMap()} }
     }

trunk/src/libcore/task/spawn.rs

@@ -96,21 +96,21 @@ macro_rules! move_it (
     { $x:expr } => ( unsafe { let y = move *ptr::addr_of(&($x)); move y } )
 )
 
-type TaskSet = send_map::linear::LinearSet<*rust_task>;
+type TaskSet = send_map::linear::LinearMap<*rust_task,()>;
 
 fn new_taskset() -> TaskSet {
-    send_map::linear::LinearSet::new()
+    send_map::linear::LinearMap()
 }
 fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) {
-    let didnt_overwrite = tasks.insert(task);
+    let didnt_overwrite = tasks.insert(task, ());
     assert didnt_overwrite;
 }
 fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     let was_present = tasks.remove(&task);
     assert was_present;
 }
 pub fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) {
-    tasks.each(|k| blk(*k))
+    tasks.each_key(|k| blk(*k))
 }
 
 // One of these per group of linked-failure tasks.

trunk/src/librustc/middle/borrowck/gather_loans.rs

@@ -30,7 +30,7 @@ use util::common::indenter;
 use util::ppaux::{expr_repr, region_to_str};
 
 use core::dvec;
-use core::send_map::linear::LinearSet;
+use core::send_map::linear::LinearMap;
 use core::vec;
 use std::map::HashMap;
 use syntax::ast::{m_const, m_imm, m_mutbl};
@@ -73,15 +73,15 @@ enum gather_loan_ctxt = @{bccx: borrowck_ctxt,
                           req_maps: req_maps,
                           mut item_ub: ast::node_id,
                           mut root_ub: ast::node_id,
-                          mut ignore_adjustments: LinearSet<ast::node_id>};
+                          mut ignore_adjustments: LinearMap<ast::node_id,()>};
 
 fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps {
     let glcx = gather_loan_ctxt(@{bccx: bccx,
                                   req_maps: {req_loan_map: HashMap(),
                                              pure_map: HashMap()},
                                   mut item_ub: 0,
                                   mut root_ub: 0,
-                                  mut ignore_adjustments: LinearSet::new()});
+                                  mut ignore_adjustments: LinearMap()});
     let v = visit::mk_vt(@visit::Visitor {visit_expr: req_loans_in_expr,
                                           visit_fn: req_loans_in_fn,
                                           visit_stmt: add_stmt_to_map,
@@ -126,7 +126,7 @@ fn req_loans_in_expr(ex: @ast::expr,
            ex.id, pprust::expr_to_str(ex, tcx.sess.intr()));
 
     // If this expression is borrowed, have to ensure it remains valid:
-    if !self.ignore_adjustments.contains(&ex.id) {
+    if !self.ignore_adjustments.contains_key(&ex.id) {
         for tcx.adjustments.find(ex.id).each |adjustments| {
             self.guarantee_adjustments(ex, *adjustments);
         }
@@ -221,7 +221,7 @@ fn req_loans_in_expr(ex: @ast::expr,
 
         // FIXME (#3387): Total hack: Ignore adjustments for the left-hand
         // side. Their regions will be inferred to be too large.
-        self.ignore_adjustments.insert(rcvr.id);
+        self.ignore_adjustments.insert(rcvr.id, ());
 
         visit::visit_expr(ex, self, vt);
       }

trunk/src/librustc/middle/borrowck/preserve.rs

@@ -358,14 +358,14 @@ priv impl &preserve_ctxt {
                 debug!("Elected to root");
                 let rk = {id: base.id, derefs: derefs};
                 // This code could potentially lead cause boxes to be frozen
-                // for longer than necessarily at runtime. It prevents an
-                // ICE in trans; the fundamental problem is that it's hard
-                // to make sure trans and borrowck have the same notion of
-                // scope. The real fix is to clean up how trans handles
-                // cleanups, but that's hard. If this becomes an issue, it's
-                // an option to just change this to `let scope_to_use =
-                // scope_id;`. Though that would potentially re-introduce
-                // the ICE. See #3511 for more details.
+                // for longer than necessarily at runtime. It prevents an ICE
+                // in trans; the fundamental problem is that it's hard to make
+                // sure trans and borrowck have the same notion of scope. The
+                // real fix is to clean up how trans handles cleanups, but
+                // that's hard. If this becomes an issue, it's an option to just
+                // change this to `let scope_to_use = scope_id;`. Though that
+                // would potentially re-introduce the ICE. See #3511 for more
+                // details.
                 let scope_to_use = if
                     self.bccx.stmt_map.contains_key(scope_id) {
                     // Root it in its parent scope, b/c

trunk/src/librustc/middle/trans/consts.rs

@@ -405,8 +405,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                     assert ast_util::is_local(def_id);
                     let f = base::get_item_val(cx, def_id.node);
                     match purity {
-                      ast::extern_fn =>
-                        llvm::LLVMConstPointerCast(f, T_ptr(T_i8())),
+                      ast::extern_fn => llvm::LLVMConstPointerCast(f, T_ptr(T_i8())),
                       _ => C_struct(~[f, C_null(T_opaque_box_ptr(cx))])
                     }
                 }

trunk/src/librustc/middle/typeck/coherence.rs

@@ -693,18 +693,18 @@ impl CoherenceChecker {
 
         let tcx = self.crate_context.tcx;
 
-        let mut provided_names = send_map::linear::LinearSet::new();
+        let mut provided_names = send_map::linear::LinearMap();
         // Implemented methods
         for uint::range(0, all_methods.len()) |i| {
-            provided_names.insert(all_methods[i].ident);
+            provided_names.insert(all_methods[i].ident, ());
         }
         // Default methods
         for ty::provided_trait_methods(tcx, trait_did).each |ident| {
-            provided_names.insert(*ident);
+            provided_names.insert(*ident, ());
         }
 
         for (*ty::trait_methods(tcx, trait_did)).each |method| {
-            if provided_names.contains(&method.ident) { loop; }
+            if provided_names.contains_key(&method.ident) { loop; }
 
             tcx.sess.span_err(trait_ref_span,
                               fmt!("missing method `%s`",

trunk/src/libstd/treemap.rs

@@ -120,8 +120,6 @@ impl <K: Ord, V> TreeMap<K, V> {
     /// Create an empty TreeMap
     static pure fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
 
-    /// Return true if the map contains some elements
-    pure fn is_not_empty(&self) -> bool { self.root.is_some() }
 
     /// Visit all key-value pairs in reverse order
     pure fn each_reverse(&self, f: fn(&K, &V) -> bool) {
@@ -176,7 +174,7 @@ impl <K: Ord, V> TreeMapIterator<K, V> {
     /// tuple with a reference to the key and value. If there are no
     /// more nodes, return `None`.
     fn next(&mut self) -> Option<(&self/K, &self/V)> {
-        while self.stack.is_not_empty() || self.node.is_some() {
+        while !self.stack.is_empty() || self.node.is_some() {
             match *self.node {
               Some(ref x) => {
                 self.stack.push(x);
@@ -240,9 +238,6 @@ impl <T: Ord> TreeSet<T> {
     /// Create an empty TreeSet
     static pure fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
 
-    /// Return true if the set contains some elements
-    pure fn is_not_empty(&self) -> bool { self.map.is_not_empty() }
-
     /// Visit all values in reverse order
     pure fn each_reverse(&self, f: fn(&T) -> bool) {
         self.map.each_key_reverse(f)
@@ -675,7 +670,6 @@ mod test_treemap {
 
     fn check_equal<K: Eq Ord, V: Eq>(ctrl: &[(K, V)], map: &TreeMap<K, V>) {
         assert ctrl.is_empty() == map.is_empty();
-        assert ctrl.is_not_empty() == map.is_not_empty();
         for ctrl.each |x| {
             let &(k, v) = x;
             assert map.find(&k).unwrap() == &v