---

yaml
---
r: 67010
b: refs/heads/master
c: babf741
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7ef9e722b8a499cd0b84ab175a366cbe536a86e4
+refs/heads/master: babf7411777a1f0318aafa24f548f2be4a64a521
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/etc/vim/compiler/rustc.vim

@@ -0,0 +1,33 @@
+" Vim compiler file
+" Compiler:         Rust Compiler
+" Maintainer:       Chris Morgan <[email protected]>
+" Latest Revision:  2013 Jul 12
+
+if exists("current_compiler")
+  finish
+endif
+let current_compiler = "rustc"
+
+let s:cpo_save = &cpo
+set cpo&vim
+
+if exists(":CompilerSet") != 2
+	command -nargs=* CompilerSet setlocal <args>
+endif
+
+if exists("g:rustc_makeprg_no_percent") && g:rustc_makeprg_no_percent == 1
+	CompilerSet makeprg=rustc
+else
+	CompilerSet makeprg=rustc\ \%
+endif
+
+CompilerSet errorformat=
+			\%f:%l:%c:\ %t%*[^:]:\ %m,
+			\%f:%l:%c:\ %*\\d:%*\\d\ %t%*[^:]:\ %m,
+			\%-G%f:%l\ %s,
+			\%-G%*[\ ]^,
+			\%-G%*[\ ]^%*[~],
+			\%-G%*[\ ]...
+
+let &cpo = s:cpo_save
+unlet s:cpo_save

trunk/src/libextra/json.rs

@@ -1086,8 +1086,9 @@ impl serialize::Decoder for Decoder {
         debug!("read_map()");
         let len = match self.stack.pop() {
             Object(obj) => {
+                let mut obj = obj;
                 let len = obj.len();
-                for obj.consume().advance |(key, value)| {
+                do obj.consume |key, value| {
                     self.stack.push(value);
                     self.stack.push(String(key));
                 }

trunk/src/libextra/test.rs

@@ -17,6 +17,7 @@
 
 
 use getopts;
+use getopts::groups;
 use json::ToJson;
 use json;
 use serialize::Decodable;
@@ -29,6 +30,7 @@ use treemap::TreeMap;
 
 use std::clone::Clone;
 use std::comm::{stream, SharedChan};
+use std::libc;
 use std::either;
 use std::io;
 use std::result;
@@ -169,22 +171,64 @@ pub struct TestOpts {
 
 type OptRes = Either<TestOpts, ~str>;
 
+fn optgroups() -> ~[getopts::groups::OptGroup] {
+    ~[groups::optflag("", "ignored", "Run ignored tests"),
+      groups::optflag("", "test", "Run tests and not benchmarks"),
+      groups::optflag("", "bench", "Run benchmarks instead of tests"),
+      groups::optflag("h", "help", "Display this message (longer with --help)"),
+      groups::optopt("", "save-metrics", "Location to save bench metrics",
+                     "PATH"),
+      groups::optopt("", "ratchet-metrics",
+                     "Location to load and save metrics from. The metrics \
+                      loaded are cause benchmarks to fail if they run too \
+                      slowly", "PATH"),
+      groups::optopt("", "ratchet-noise-percent",
+                     "Tests within N% of the recorded metrics will be \
+                      considered as passing", "PERCENTAGE"),
+      groups::optopt("", "logfile", "Write logs to the specified file instead \
+                          of stdout", "PATH")]
+}
+
+fn usage(binary: &str, helpstr: &str) -> ! {
+    let message = fmt!("Usage: %s [OPTIONS] [FILTER]", binary);
+    println(groups::usage(message, optgroups()));
+    if helpstr == "help" {
+        println("\
+The FILTER is matched against the name of all tests to run, and if any tests
+have a substring match, only those tests are run.
+
+By default, all tests are run in parallel. This can be altered with the
+RUST_THREADS environment variable when running tests (set it to 1).
+
+Test Attributes:
+
+    #[test]        - Indicates a function is a test to be run. This function
+                     takes no arguments.
+    #[bench]       - Indicates a function is a benchmark to be run. This
+                     function takes one argument (extra::test::BenchHarness).
+    #[should_fail] - This function (also labeled with #[test]) will only pass if
+                     the code causes a failure (an assertion failure or fail!)
+    #[ignore]      - When applied to a function which is already attributed as a
+                     test, then the test runner will ignore these tests during
+                     normal test runs. Running with --ignored will run these
+                     tests. This may also be written as #[ignore(cfg(...))] to
+                     ignore the test on certain configurations.");
+    }
+    unsafe { libc::exit(0) }
+}
+
 // Parses command line arguments into test options
 pub fn parse_opts(args: &[~str]) -> OptRes {
     let args_ = args.tail();
-    let opts = ~[getopts::optflag("ignored"),
-                 getopts::optflag("test"),
-                 getopts::optflag("bench"),
-                 getopts::optopt("save-metrics"),
-                 getopts::optopt("ratchet-metrics"),
-                 getopts::optopt("ratchet-noise-percent"),
-                 getopts::optopt("logfile")];
     let matches =
-        match getopts::getopts(args_, opts) {
+        match groups::getopts(args_, optgroups()) {
           Ok(m) => m,
           Err(f) => return either::Right(getopts::fail_str(f))
         };
 
+    if getopts::opt_present(&matches, "h") { usage(args[0], "h"); }
+    if getopts::opt_present(&matches, "help") { usage(args[0], "help"); }
+
     let filter =
         if matches.free.len() > 0 {
             Some((matches).free[0].clone())

trunk/src/librustc/rustc.rs

@@ -154,7 +154,7 @@ Available lint options:
 "));
 
     let lint_dict = lint::get_lint_dict();
-    let mut lint_dict = lint_dict.consume()
+    let mut lint_dict = lint_dict.consume_iter()
                                  .transform(|(k, v)| (v, k))
                                  .collect::<~[(lint::LintSpec, &'static str)]>();
     lint_dict.qsort();

trunk/src/librusti/program.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use std::cast;
-use std::util;
 use std::hashmap::HashMap;
 use std::local_data;
 
@@ -166,8 +165,7 @@ impl Program {
             None => {}
         }
 
-        let newvars = util::replace(&mut self.newvars, HashMap::new());
-        for newvars.consume().advance |(name, var)| {
+        do self.newvars.consume |name, var| {
             self.local_vars.insert(name, var);
         }
 
@@ -232,8 +230,7 @@ impl Program {
     /// it updates this cache with the new values of each local variable.
     pub fn consume_cache(&mut self) {
         let map = local_data::pop(tls_key).expect("tls is empty");
-        let cons_map = util::replace(map, HashMap::new());
-        for cons_map.consume().advance |(name, value)| {
+        do map.consume |name, value| {
             match self.local_vars.find_mut(&name) {
                 Some(v) => { v.data = (*value).clone(); }
                 None => { fail!("unknown variable %s", name) }
@@ -344,8 +341,7 @@ impl Program {
         }
 
         // I'm not an @ pointer, so this has to be done outside.
-        let cons_newvars = util::replace(newvars, HashMap::new());
-        for cons_newvars.consume().advance |(k, v)| {
+        do newvars.consume |k, v| {
             self.newvars.insert(k, v);
         }
 

trunk/src/libstd/hashmap.rs

@@ -438,6 +438,31 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
         self.mangle(k, v, |_k,a| a, |k,v,_a| f(k,v))
     }
 
+    /// Calls a function on each element of a hash map, destroying the hash
+    /// map in the process.
+    pub fn consume(&mut self, f: &fn(K, V)) {
+        let buckets = replace(&mut self.buckets,
+                              vec::from_fn(INITIAL_CAPACITY, |_| None));
+        self.size = 0;
+
+        for buckets.consume_iter().advance |bucket| {
+            match bucket {
+                None => {},
+                Some(Bucket{key, value, _}) => {
+                    f(key, value)
+                }
+            }
+        }
+    }
+
+    /// Creates a consuming iterator, that is, one that moves each key-value
+    /// pair out of the map in arbitrary order. The map cannot be used after
+    /// calling this.
+    pub fn consume_iter(self) -> HashMapConsumeIterator<K, V> {
+        // `consume_rev_iter` is more efficient than `consume_iter` for vectors
+        HashMapConsumeIterator {iter: self.buckets.consume_rev_iter()}
+    }
+
     /// Retrieves a value for the given key, failing if the key is not
     /// present.
     pub fn get<'a>(&'a self, k: &K) -> &'a V {
@@ -497,15 +522,6 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     pub fn mut_iter<'a>(&'a mut self) -> HashMapMutIterator<'a, K, V> {
         HashMapMutIterator { iter: self.buckets.mut_iter() }
     }
-
-    /// Creates a consuming iterator, that is, one that moves each key-value
-    /// pair out of the map in arbitrary order. The map cannot be used after
-    /// calling this.
-    pub fn consume(self) -> HashMapConsumeIterator<K, V> {
-        // `consume_rev_iter` is more efficient than `consume_iter` for vectors
-        HashMapConsumeIterator {iter: self.buckets.consume_rev_iter()}
-    }
-
 }
 
 impl<K: Hash + Eq, V: Clone> HashMap<K, V> {
@@ -745,6 +761,19 @@ impl<T:Hash + Eq> HashSet<T> {
         self.map.reserve_at_least(n)
     }
 
+    /// Consumes all of the elements in the set, emptying it out
+    pub fn consume(&mut self, f: &fn(T)) {
+        self.map.consume(|k, _| f(k))
+    }
+
+    /// Creates a consuming iterator, that is, one that moves each value out
+    /// of the set in arbitrary order. The set cannot be used after calling
+    /// this.
+    pub fn consume_iter(self) -> HashSetConsumeIterator<T> {
+        // `consume_rev_iter` is more efficient than `consume_iter` for vectors
+        HashSetConsumeIterator {iter: self.map.buckets.consume_rev_iter()}
+    }
+
     /// Returns true if the hash set contains a value equivalent to the
     /// given query value.
     pub fn contains_equiv<Q:Hash + Equiv<T>>(&self, value: &Q) -> bool {
@@ -757,14 +786,6 @@ impl<T:Hash + Eq> HashSet<T> {
         HashSetIterator { iter: self.map.buckets.iter() }
     }
 
-    /// Creates a consuming iterator, that is, one that moves each value out
-    /// of the set in arbitrary order. The set cannot be used after calling
-    /// this.
-    pub fn consume(self) -> HashSetConsumeIterator<T> {
-        // `consume_rev_iter` is more efficient than `consume_iter` for vectors
-        HashSetConsumeIterator {iter: self.map.buckets.consume_rev_iter()}
-    }
-
     /// Visit the values representing the difference
     pub fn difference_iter<'a>(&'a self, other: &'a HashSet<T>)
         -> SetAlgebraIter<'a, T> {
@@ -954,6 +975,29 @@ mod test_map {
 
     #[test]
     fn test_consume() {
+        let mut m = HashMap::new();
+        assert!(m.insert(1, 2));
+        assert!(m.insert(2, 3));
+        let mut m2 = HashMap::new();
+        do m.consume |k, v| {
+            m2.insert(k, v);
+        }
+        assert_eq!(m.len(), 0);
+        assert_eq!(m2.len(), 2);
+        assert_eq!(m2.get(&1), &2);
+        assert_eq!(m2.get(&2), &3);
+    }
+
+    #[test]
+    fn test_consume_still_usable() {
+        let mut m = HashMap::new();
+        assert!(m.insert(1, 2));
+        do m.consume |_, _| {}
+        assert!(m.insert(1, 2));
+    }
+
+    #[test]
+    fn test_consume_iter() {
         let hm = {
             let mut hm = HashMap::new();
 
@@ -963,7 +1007,7 @@ mod test_map {
             hm
         };
 
-        let v = hm.consume().collect::<~[(char, int)]>();
+        let v = hm.consume_iter().collect::<~[(char, int)]>();
         assert!([('a', 1), ('b', 2)] == v || [('b', 2), ('a', 1)] == v);
     }
 
@@ -1249,7 +1293,7 @@ mod test_set {
     }
 
     #[test]
-    fn test_consume() {
+    fn test_consume_iter() {
         let hs = {
             let mut hs = HashSet::new();
 
@@ -1259,7 +1303,7 @@ mod test_set {
             hs
         };
 
-        let v = hs.consume().collect::<~[char]>();
+        let v = hs.consume_iter().collect::<~[char]>();
         assert!(['a', 'b'] == v || ['b', 'a'] == v);
     }
 }

trunk/src/libstd/unstable/weak_task.rs

@@ -122,7 +122,7 @@ fn run_weak_task_service(port: Port<ServiceMsg>) {
         }
     }
 
-    for shutdown_map.consume().advance |(_, shutdown_chan)| {
+    do shutdown_map.consume |_, shutdown_chan| {
         // Weak task may have already exited
         shutdown_chan.send(());
     }

trunk/src/test/bench/graph500-bfs.rs

@@ -96,9 +96,9 @@ fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph {
         }
     }
 
-    do graph.consume_iter().transform |v| {
+    do graph.consume_iter().transform |mut v| {
         let mut vec = ~[];
-        for v.consume().advance |i| {
+        do v.consume |i| {
             vec.push(i);
         }
         vec
@@ -119,7 +119,7 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] {
         }
     }
     let mut vec = ~[];
-    for keys.consume().advance |i| {
+    do keys.consume |i| {
         vec.push(i);
     }
     return vec;