---

yaml
---
r: 52440
b: refs/heads/dist-snap
c: 2c870e4
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 7eb8642aed3cd12a836c75aff25cbaf2dfc35017
+refs/heads/dist-snap: 2c870e40744b873bf3205af7b2057cf4f76c3d1f
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

branches/dist-snap/src/libcore/send_map.rs

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

branches/dist-snap/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::LinearMap<*rust_task,()>;
+type TaskSet = send_map::linear::LinearSet<*rust_task>;
 
 fn new_taskset() -> TaskSet {
-    send_map::linear::LinearMap()
+    send_map::linear::LinearSet::new()
 }
 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_key(|k| blk(*k))
+    tasks.each(|k| blk(*k))
 }
 
 // One of these per group of linked-failure tasks.

branches/dist-snap/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::LinearMap;
+use core::send_map::linear::LinearSet;
 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: LinearMap<ast::node_id,()>};
+                          mut ignore_adjustments: LinearSet<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: LinearMap()});
+                                  mut ignore_adjustments: LinearSet::new()});
     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_key(&ex.id) {
+    if !self.ignore_adjustments.contains(&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);
       }

branches/dist-snap/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

branches/dist-snap/src/librustc/middle/trans/consts.rs

@@ -405,7 +405,8 @@ 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))])
                     }
                 }

branches/dist-snap/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::LinearMap();
+        let mut provided_names = send_map::linear::LinearSet::new();
         // 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_key(&method.ident) { loop; }
+            if provided_names.contains(&method.ident) { loop; }
 
             tcx.sess.span_err(trait_ref_span,
                               fmt!("missing method `%s`",

branches/dist-snap/src/libstd/time.rs

@@ -1025,6 +1025,7 @@ mod tests {
     }
 
     #[test]
+    #[ignore(reason = "randomred")]
     fn test_strptime() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();

branches/dist-snap/src/libstd/treemap.rs

@@ -120,6 +120,8 @@ 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) {
@@ -174,7 +176,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_empty() || self.node.is_some() {
+        while self.stack.is_not_empty() || self.node.is_some() {
             match *self.node {
               Some(ref x) => {
                 self.stack.push(x);
@@ -238,6 +240,9 @@ 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)
@@ -670,6 +675,7 @@ 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