From 9218aaa00ed0883d3a082f8753a206fb6d03dac9 Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Sun, 4 Aug 2013 16:05:25 -0700
Subject: std: add result.map_move, result.map_err_move

---
 src/libstd/local_data.rs | 12 +++++------
 src/libstd/result.rs     | 56 ++++++++++++++++++++++++++++++++++++++++++++----
 src/libstd/rt/task.rs    |  4 ++--
 3 files changed, 60 insertions(+), 12 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index c2a60e1c0e9..a73809d202c 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -110,16 +110,16 @@ fn test_tls_multitask() {
     set(my_key, @~"parent data");
     do task::spawn {
         // TLS shouldn't carry over.
-        assert!(get(my_key, |k| k.map(|&k| *k)).is_none());
+        assert!(get(my_key, |k| k.map_move(|k| *k)).is_none());
         set(my_key, @~"child data");
-        assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) ==
+        assert!(*(get(my_key, |k| k.map_move(|k| *k)).unwrap()) ==
                 ~"child data");
         // should be cleaned up for us
     }
     // Must work multiple times
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
+    assert!(*(get(my_key, |k| k.map_move(|k| *k)).unwrap()) == ~"parent data");
+    assert!(*(get(my_key, |k| k.map_move(|k| *k)).unwrap()) == ~"parent data");
+    assert!(*(get(my_key, |k| k.map_move(|k| *k)).unwrap()) == ~"parent data");
 }
 
 #[test]
@@ -127,7 +127,7 @@ fn test_tls_overwrite() {
     static my_key: Key<@~str> = &Key;
     set(my_key, @~"first data");
     set(my_key, @~"next data"); // Shouldn't leak.
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"next data");
+    assert!(*(get(my_key, |k| k.map_move(|k| *k)).unwrap()) == ~"next data");
 }
 
 #[test]
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 91f42edf0ae..e62ae3885eb 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -149,6 +149,40 @@ impl<T, E: ToStr> Result<T, E> {
         }
     }
 
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Ok` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is wrapped in `Ok` and returned. if `self` is
+    /// `Err` then it is immediately returned.  This function can be used to
+    /// compose the results of two functions.
+    ///
+    /// Example:
+    ///
+    ///     let res = do read_file(file).map_move |buf| {
+    ///         parse_bytes(buf)
+    ///     }
+    #[inline]
+    pub fn map_move<U>(self, op: &fn(T) -> U) -> Result<U,E> {
+        match self {
+          Ok(t) => Ok(op(t)),
+          Err(e) => Err(e)
+        }
+    }
+
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Err` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is wrapped in an `Err` and returned. if `self` is
+    /// `Ok` then it is immediately returned.  This function can be used to pass
+    /// through a successful result while handling an error.
+    #[inline]
+    pub fn map_err_move<F>(self, op: &fn(E) -> F) -> Result<T,F> {
+        match self {
+          Ok(t) => Ok(t),
+          Err(e) => Err(op(e))
+        }
+    }
+
     /// Call a method based on a previous result
     ///
     /// If `self` is `Ok` then the value is extracted and passed to `op`
@@ -312,7 +346,9 @@ pub fn iter_vec2<S, T, U: ToStr>(ss: &[S], ts: &[T],
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use either;
+    use str::OwnedStr;
 
     pub fn op1() -> Result<int, ~str> { Ok(666) }
 
@@ -359,14 +395,26 @@ mod tests {
 
     #[test]
     pub fn test_impl_map() {
-        assert_eq!(Ok::<~str, ~str>(~"a").map(|_x| ~"b"), Ok(~"b"));
-        assert_eq!(Err::<~str, ~str>(~"a").map(|_x| ~"b"), Err(~"a"));
+        assert_eq!(Ok::<~str, ~str>(~"a").map(|x| (~"b").append(*x)), Ok(~"ba"));
+        assert_eq!(Err::<~str, ~str>(~"a").map(|x| (~"b").append(*x)), Err(~"a"));
     }
 
     #[test]
     pub fn test_impl_map_err() {
-        assert_eq!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b"), Ok(~"a"));
-        assert_eq!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b"), Err(~"b"));
+        assert_eq!(Ok::<~str, ~str>(~"a").map_err(|x| (~"b").append(*x)), Ok(~"a"));
+        assert_eq!(Err::<~str, ~str>(~"a").map_err(|x| (~"b").append(*x)), Err(~"ba"));
+    }
+
+    #[test]
+    pub fn test_impl_map_move() {
+        assert_eq!(Ok::<~str, ~str>(~"a").map_move(|x| x + ~"b"), Ok(~"ab"));
+        assert_eq!(Err::<~str, ~str>(~"a").map_move(|x| x + ~"b"), Err(~"a"));
+    }
+
+    #[test]
+    pub fn test_impl_map_err_move() {
+        assert_eq!(Ok::<~str, ~str>(~"a").map_err_move(|x| x + ~"b"), Ok(~"a"));
+        assert_eq!(Err::<~str, ~str>(~"a").map_err_move(|x| x + ~"b"), Err(~"ab"));
     }
 
     #[test]
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 4c5e4bdc3c1..e732ef67b5b 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -465,10 +465,10 @@ mod test {
         do run_in_newsched_task() {
             static key: local_data::Key<@~str> = &local_data::Key;
             local_data::set(key, @~"data");
-            assert!(*local_data::get(key, |k| k.map(|&k| *k)).unwrap() == ~"data");
+            assert!(*local_data::get(key, |k| k.map_move(|k| *k)).unwrap() == ~"data");
             static key2: local_data::Key<@~str> = &local_data::Key;
             local_data::set(key2, @~"data");
-            assert!(*local_data::get(key2, |k| k.map(|&k| *k)).unwrap() == ~"data");
+            assert!(*local_data::get(key2, |k| k.map_move(|k| *k)).unwrap() == ~"data");
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 1e490813b017f99cb4385fe846d645efe5d62b62 Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Sun, 4 Aug 2013 14:59:36 -0700
Subject: core: option.map_consume -> option.map_move

---
 src/compiletest/compiletest.rs                  | 14 ++++++-------
 src/libextra/dlist.rs                           | 20 +++++++++---------
 src/libextra/num/bigint.rs                      |  4 ++--
 src/libextra/smallintmap.rs                     |  2 +-
 src/libextra/term.rs                            |  4 ++--
 src/libextra/test.rs                            |  8 +++----
 src/libextra/treemap.rs                         |  2 +-
 src/librust/rust.rs                             |  2 +-
 src/librustc/driver/driver.rs                   |  3 +--
 src/librustc/front/config.rs                    | 10 ++++++---
 src/librustc/lib/llvm.rs                        |  2 +-
 src/librustc/metadata/cstore.rs                 |  2 +-
 src/librustc/metadata/decoder.rs                | 12 +++++------
 src/librustc/middle/borrowck/mod.rs             | 10 +++++----
 src/librustc/middle/const_eval.rs               |  4 ++--
 src/librustc/middle/lang_items.rs               |  2 +-
 src/librustc/middle/liveness.rs                 | 12 +++++------
 src/librustc/middle/region.rs                   |  5 ++---
 src/librustc/middle/resolve.rs                  |  2 +-
 src/librustc/middle/trans/base.rs               |  6 +++---
 src/librustc/middle/trans/cabi_mips.rs          |  2 +-
 src/librustc/middle/trans/common.rs             |  3 +--
 src/librustc/middle/trans/context.rs            |  2 +-
 src/librustc/middle/trans/meth.rs               |  4 ++--
 src/librustc/middle/ty.rs                       |  7 ++++---
 src/librustc/middle/typeck/astconv.rs           |  4 ++--
 src/librustc/middle/typeck/check/_match.rs      | 20 +++++++++---------
 src/librustc/middle/typeck/check/mod.rs         | 17 +++++++--------
 src/librustc/middle/typeck/check/regionmanip.rs |  8 +++----
 src/librustc/middle/typeck/collect.rs           | 10 ++++-----
 src/librustc/middle/typeck/infer/mod.rs         | 13 ++++++------
 src/librustc/rustc.rs                           | 11 +++++-----
 src/librustdoc/config.rs                        | 10 ++++-----
 src/librustdoc/tystr_pass.rs                    |  4 ++--
 src/librusti/rusti.rs                           |  2 +-
 src/libstd/hashmap.rs                           |  4 ++--
 src/libstd/iterator.rs                          |  8 +++----
 src/libstd/option.rs                            | 28 ++++++++++++-------------
 src/libstd/os.rs                                |  4 +---
 src/libstd/result.rs                            |  8 +++----
 src/libstd/rt/comm.rs                           |  4 ++--
 src/libstd/rt/kill.rs                           |  4 ++--
 src/libstd/rt/sched.rs                          |  4 ++--
 src/libstd/str.rs                               |  2 +-
 src/libstd/task/spawn.rs                        |  6 +++---
 src/libsyntax/ast_util.rs                       |  2 +-
 src/libsyntax/attr.rs                           |  2 +-
 src/libsyntax/diagnostic.rs                     |  2 +-
 src/libsyntax/ext/base.rs                       |  2 +-
 src/libsyntax/ext/build.rs                      |  2 +-
 src/libsyntax/fold.rs                           | 22 +++++++++----------
 src/libsyntax/parse/parser.rs                   |  2 +-
 src/libsyntax/parse/token.rs                    |  2 +-
 53 files changed, 176 insertions(+), 175 deletions(-)

(limited to 'src/libstd')

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 4e4261e8b2b..4262aba9a85 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -109,8 +109,8 @@ pub fn parse_config(args: ~[~str]) -> config {
         compile_lib_path: getopts::opt_str(matches, "compile-lib-path"),
         run_lib_path: getopts::opt_str(matches, "run-lib-path"),
         rustc_path: opt_path(matches, "rustc-path"),
-        clang_path: getopts::opt_maybe_str(matches, "clang-path").map(|s| Path(*s)),
-        llvm_bin_path: getopts::opt_maybe_str(matches, "llvm-bin-path").map(|s| Path(*s)),
+        clang_path: getopts::opt_maybe_str(matches, "clang-path").map_move(|s| Path(s)),
+        llvm_bin_path: getopts::opt_maybe_str(matches, "llvm-bin-path").map_move(|s| Path(s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
@@ -123,14 +123,14 @@ pub fn parse_config(args: ~[~str]) -> config {
             } else {
                 None
             },
-        logfile: getopts::opt_maybe_str(matches, "logfile").map(|s| Path(*s)),
-        save_metrics: getopts::opt_maybe_str(matches, "save-metrics").map(|s| Path(*s)),
+        logfile: getopts::opt_maybe_str(matches, "logfile").map_move(|s| Path(s)),
+        save_metrics: getopts::opt_maybe_str(matches, "save-metrics").map_move(|s| Path(s)),
         ratchet_metrics:
-            getopts::opt_maybe_str(matches, "ratchet-metrics").map(|s| Path(*s)),
+            getopts::opt_maybe_str(matches, "ratchet-metrics").map_move(|s| Path(s)),
         ratchet_noise_percent:
             getopts::opt_maybe_str(matches,
-                                   "ratchet-noise-percent").map(|s|
-                                                                f64::from_str(*s).unwrap()),
+                                   "ratchet-noise-percent").map_move(|s|
+                                                                     f64::from_str(s).unwrap()),
         runtool: getopts::opt_maybe_str(matches, "runtool"),
         rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
         jit: getopts::opt_present(matches, "jit"),
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
index 75487a44f26..b0839a55795 100644
--- a/src/libextra/dlist.rs
+++ b/src/libextra/dlist.rs
@@ -164,7 +164,7 @@ impl<T> DList<T> {
     /// Remove the first Node and return it, or None if the list is empty
     #[inline]
     fn pop_front_node(&mut self) -> Option<~Node<T>> {
-        do self.list_head.take().map_consume |mut front_node| {
+        do self.list_head.take().map_move |mut front_node| {
             self.length -= 1;
             match front_node.next.take() {
                 Some(node) => self.list_head = link_with_prev(node, Rawlink::none()),
@@ -190,7 +190,7 @@ impl<T> DList<T> {
     /// Remove the last Node and return it, or None if the list is empty
     #[inline]
     fn pop_back_node(&mut self) -> Option<~Node<T>> {
-        do self.list_tail.resolve().map_consume_default(None) |tail| {
+        do self.list_tail.resolve().map_move_default(None) |tail| {
             self.length -= 1;
             self.list_tail = tail.prev;
             match tail.prev.resolve() {
@@ -237,7 +237,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_front(&mut self) -> Option<T> {
-        self.pop_front_node().map_consume(|~Node{value, _}| value)
+        self.pop_front_node().map_move(|~Node{value, _}| value)
     }
 
     /// Add an element last in the list
@@ -251,7 +251,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_back(&mut self) -> Option<T> {
-        self.pop_back_node().map_consume(|~Node{value, _}| value)
+        self.pop_back_node().map_move(|~Node{value, _}| value)
     }
 }
 
@@ -267,7 +267,7 @@ impl<T> DList<T> {
     /// If the list is empty, do nothing.
     #[inline]
     pub fn rotate_forward(&mut self) {
-        do self.pop_back_node().map_consume |tail| {
+        do self.pop_back_node().map_move |tail| {
             self.push_front_node(tail)
         };
     }
@@ -277,7 +277,7 @@ impl<T> DList<T> {
     /// If the list is empty, do nothing.
     #[inline]
     pub fn rotate_backward(&mut self) {
-        do self.pop_front_node().map_consume |head| {
+        do self.pop_front_node().map_move |head| {
             self.push_back_node(head)
         };
     }
@@ -463,7 +463,7 @@ impl<'self, A> DoubleEndedIterator<&'self A> for DListIterator<'self, A> {
         if self.nelem == 0 {
             return None;
         }
-        do self.tail.resolve().map_consume |prev| {
+        do self.tail.resolve().map_move |prev| {
             self.nelem -= 1;
             self.tail = prev.prev;
             &prev.value
@@ -477,7 +477,7 @@ impl<'self, A> Iterator<&'self mut A> for MutDListIterator<'self, A> {
         if self.nelem == 0 {
             return None;
         }
-        do self.head.resolve().map_consume |next| {
+        do self.head.resolve().map_move |next| {
             self.nelem -= 1;
             self.head = match next.next {
                 Some(ref mut node) => Rawlink::some(&mut **node),
@@ -499,7 +499,7 @@ impl<'self, A> DoubleEndedIterator<&'self mut A> for MutDListIterator<'self, A>
         if self.nelem == 0 {
             return None;
         }
-        do self.tail.resolve().map_consume |prev| {
+        do self.tail.resolve().map_move |prev| {
             self.nelem -= 1;
             self.tail = prev.prev;
             &mut prev.value
@@ -553,7 +553,7 @@ impl<'self, A> ListInsertion<A> for MutDListIterator<'self, A> {
         if self.nelem == 0 {
             return None
         }
-        self.head.resolve().map_consume(|head| &mut head.value)
+        self.head.resolve().map_move(|head| &mut head.value)
     }
 }
 
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index 890f5e40e97..c3737d44e38 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -548,7 +548,7 @@ impl BigUint {
 
     pub fn new(v: ~[BigDigit]) -> BigUint {
         // omit trailing zeros
-        let new_len = v.rposition(|n| *n != 0).map_default(0, |p| *p + 1);
+        let new_len = v.rposition(|n| *n != 0).map_move_default(0, |p| p + 1);
 
         if new_len == v.len() { return BigUint { data: v }; }
         let mut v = v;
@@ -1145,7 +1145,7 @@ impl BigInt {
             start = 1;
         }
         return BigUint::parse_bytes(buf.slice(start, buf.len()), radix)
-            .map_consume(|bu| BigInt::from_biguint(sign, bu));
+            .map_move(|bu| BigInt::from_biguint(sign, bu));
     }
 
     pub fn to_uint(&self) -> uint {
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index 3f62317eb89..e5116f19afa 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -203,7 +203,7 @@ impl<V> SmallIntMap<V> {
     {
         let values = replace(&mut self.v, ~[]);
         values.consume_iter().enumerate().filter_map(|(i, v)| {
-            v.map_consume(|v| (i, v))
+            v.map_move(|v| (i, v))
         })
     }
 }
diff --git a/src/libextra/term.rs b/src/libextra/term.rs
index 1cfb4f4afa6..2173eb838e5 100644
--- a/src/libextra/term.rs
+++ b/src/libextra/term.rs
@@ -127,7 +127,7 @@ impl Terminal {
         let inf = ti.unwrap();
         let nc = if inf.strings.find_equiv(&("setaf")).is_some()
                  && inf.strings.find_equiv(&("setab")).is_some() {
-                     inf.numbers.find_equiv(&("colors")).map_consume_default(0, |&n| n)
+                     inf.numbers.find_equiv(&("colors")).map_move_default(0, |&n| n)
                  } else { 0 };
 
         return Ok(Terminal {out: out, ti: inf, num_colors: nc});
@@ -220,7 +220,7 @@ impl Terminal {
                 cap = self.ti.strings.find_equiv(&("op"));
             }
         }
-        let s = do cap.map_consume_default(Err(~"can't find terminfo capability `sgr0`")) |op| {
+        let s = do cap.map_move_default(Err(~"can't find terminfo capability `sgr0`")) |op| {
             expand(*op, [], &mut Variables::new())
         };
         if s.is_ok() {
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index e87be146226..761cb1bd76f 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -238,20 +238,20 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
     let run_ignored = getopts::opt_present(&matches, "ignored");
 
     let logfile = getopts::opt_maybe_str(&matches, "logfile");
-    let logfile = logfile.map(|s| Path(*s));
+    let logfile = logfile.map_move(|s| Path(s));
 
     let run_benchmarks = getopts::opt_present(&matches, "bench");
     let run_tests = ! run_benchmarks ||
         getopts::opt_present(&matches, "test");
 
     let ratchet_metrics = getopts::opt_maybe_str(&matches, "ratchet-metrics");
-    let ratchet_metrics = ratchet_metrics.map(|s| Path(*s));
+    let ratchet_metrics = ratchet_metrics.map_move(|s| Path(s));
 
     let ratchet_noise_percent = getopts::opt_maybe_str(&matches, "ratchet-noise-percent");
-    let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).unwrap());
+    let ratchet_noise_percent = ratchet_noise_percent.map_move(|s| f64::from_str(s).unwrap());
 
     let save_metrics = getopts::opt_maybe_str(&matches, "save-metrics");
-    let save_metrics = save_metrics.map(|s| Path(*s));
+    let save_metrics = save_metrics.map_move(|s| Path(s));
 
     let test_opts = TestOpts {
         filter: filter,
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 487ad050e78..ab7d47255da 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -394,7 +394,7 @@ impl<'self, T> Iterator<&'self T> for TreeSetIterator<'self, T> {
     /// Advance the iterator to the next node (in order). If there are no more nodes, return `None`.
     #[inline]
     fn next(&mut self) -> Option<&'self T> {
-        do self.iter.next().map |&(value, _)| { value }
+        do self.iter.next().map_move |(value, _)| { value }
     }
 }
 
diff --git a/src/librust/rust.rs b/src/librust/rust.rs
index 1ac8146bb58..010486cdf85 100644
--- a/src/librust/rust.rs
+++ b/src/librust/rust.rs
@@ -130,7 +130,7 @@ fn rustc_help() {
 fn find_cmd(command_string: &str) -> Option<Command> {
     do COMMANDS.iter().find_ |command| {
         command.cmd == command_string
-    }.map_consume(|x| *x)
+    }.map_move(|x| *x)
 }
 
 fn cmd_help(args: &[~str]) -> ValidUsage {
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 2c642d54253..61ab826e9ee 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -669,8 +669,7 @@ pub fn build_session_options(binary: @str,
         } else if opt_present(matches, "emit-llvm") {
             link::output_type_bitcode
         } else { link::output_type_exe };
-    let sysroot_opt = getopts::opt_maybe_str(matches, "sysroot");
-    let sysroot_opt = sysroot_opt.map(|m| @Path(*m));
+    let sysroot_opt = getopts::opt_maybe_str(matches, "sysroot").map_move(|m| @Path(m));
     let target_opt = getopts::opt_maybe_str(matches, "target");
     let target_feature_opt = getopts::opt_maybe_str(matches, "target-feature");
     let save_temps = getopts::opt_present(matches, "save-temps");
diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs
index d8b59d579c8..d6584846655 100644
--- a/src/librustc/front/config.rs
+++ b/src/librustc/front/config.rs
@@ -61,7 +61,9 @@ fn fold_mod(cx: @Context, m: &ast::_mod, fld: @fold::ast_fold) -> ast::_mod {
         filter_item(cx, *a).chain(|x| fld.fold_item(x))
     }.collect();
     let filtered_view_items = do m.view_items.iter().filter_map |a| {
-        filter_view_item(cx, a).map(|&x| fld.fold_view_item(x))
+        do filter_view_item(cx, a).map_move |x| {
+            fld.fold_view_item(x)
+        }
     }.collect();
     ast::_mod {
         view_items: filtered_view_items,
@@ -83,7 +85,9 @@ fn fold_foreign_mod(
 ) -> ast::foreign_mod {
     let filtered_items = nm.items.iter().filter_map(|a| filter_foreign_item(cx, *a)).collect();
     let filtered_view_items = do nm.view_items.iter().filter_map |a| {
-        filter_view_item(cx, a).map(|&x| fld.fold_view_item(x))
+        do filter_view_item(cx, a).map_move |x| {
+            fld.fold_view_item(x)
+        }
     }.collect();
     ast::foreign_mod {
         sort: nm.sort,
@@ -138,7 +142,7 @@ fn fold_block(
         filter_stmt(cx, *a).chain(|stmt| fld.fold_stmt(stmt))
     }.collect();
     let filtered_view_items = do b.view_items.iter().filter_map |a| {
-        filter_view_item(cx, a).map(|&x| fld.fold_view_item(x))
+        filter_view_item(cx, a).map(|x| fld.fold_view_item(*x))
     }.collect();
     ast::Block {
         view_items: filtered_view_items,
diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs
index 356cdaf754e..90db3f8edb0 100644
--- a/src/librustc/lib/llvm.rs
+++ b/src/librustc/lib/llvm.rs
@@ -2159,7 +2159,7 @@ impl TypeNames {
     }
 
     pub fn find_type(&self, s: &str) -> Option<Type> {
-        self.named_types.find_equiv(&s).map_consume(|x| Type::from_ref(*x))
+        self.named_types.find_equiv(&s).map_move(|x| Type::from_ref(*x))
     }
 
     // We have a depth count, because we seem to make infinite types.
diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs
index 33623a40cfb..a5f541412de 100644
--- a/src/librustc/metadata/cstore.rs
+++ b/src/librustc/metadata/cstore.rs
@@ -133,7 +133,7 @@ pub fn add_extern_mod_stmt_cnum(cstore: &mut CStore,
 pub fn find_extern_mod_stmt_cnum(cstore: &CStore,
                                  emod_id: ast::NodeId)
                        -> Option<ast::CrateNum> {
-    cstore.extern_mod_crate_map.find(&emod_id).map_consume(|x| *x)
+    cstore.extern_mod_crate_map.find(&emod_id).map_move(|x| *x)
 }
 
 #[deriving(Clone)]
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index c3097d1aa66..8d357126018 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -198,8 +198,8 @@ fn item_def_id(d: ebml::Doc, cdata: cmd) -> ast::def_id {
 }
 
 fn get_provided_source(d: ebml::Doc, cdata: cmd) -> Option<ast::def_id> {
-    do reader::maybe_get_doc(d, tag_item_method_provided_source).map |doc| {
-        translate_def_id(cdata, reader::with_doc_data(*doc, parse_def_id))
+    do reader::maybe_get_doc(d, tag_item_method_provided_source).map_move |doc| {
+        translate_def_id(cdata, reader::with_doc_data(doc, parse_def_id))
     }
 }
 
@@ -265,10 +265,10 @@ fn item_ty_param_defs(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd,
 }
 
 fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
-    reader::maybe_get_doc(item, tag_region_param).map(|doc| {
-        let mut decoder = reader::Decoder(*doc);
+    do reader::maybe_get_doc(item, tag_region_param).map_move |doc| {
+        let mut decoder = reader::Decoder(doc);
         Decodable::decode(&mut decoder)
-    })
+    }
 }
 
 fn item_ty_param_count(item: ebml::Doc) -> uint {
@@ -415,7 +415,7 @@ pub fn get_impl_trait(cdata: cmd,
                        tcx: ty::ctxt) -> Option<@ty::TraitRef>
 {
     let item_doc = lookup_item(id, cdata.data);
-    do reader::maybe_get_doc(item_doc, tag_item_trait_ref).map |&tp| {
+    do reader::maybe_get_doc(item_doc, tag_item_trait_ref).map_move |tp| {
         @doc_trait_ref(tp, tcx, cdata)
     }
 }
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index 3db90ed5d74..d410021063c 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -286,13 +286,15 @@ pub fn opt_loan_path(cmt: mc::cmt) -> Option<@LoanPath> {
         }
 
         mc::cat_deref(cmt_base, _, _) => {
-            opt_loan_path(cmt_base).map(
-                |&lp| @LpExtend(lp, cmt.mutbl, LpDeref))
+            do opt_loan_path(cmt_base).map_move |lp| {
+                @LpExtend(lp, cmt.mutbl, LpDeref)
+            }
         }
 
         mc::cat_interior(cmt_base, ik) => {
-            opt_loan_path(cmt_base).map(
-                |&lp| @LpExtend(lp, cmt.mutbl, LpInterior(ik)))
+            do opt_loan_path(cmt_base).map_move |lp| {
+                @LpExtend(lp, cmt.mutbl, LpInterior(ik))
+            }
         }
 
         mc::cat_downcast(cmt_base) |
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index 77e81709a03..3b56764f2fc 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -493,9 +493,9 @@ pub fn compare_lit_exprs(tcx: middle::ty::ctxt, a: &expr, b: &expr) -> Option<in
 }
 
 pub fn lit_expr_eq(tcx: middle::ty::ctxt, a: &expr, b: &expr) -> Option<bool> {
-    compare_lit_exprs(tcx, a, b).map(|&val| val == 0)
+    compare_lit_exprs(tcx, a, b).map_move(|val| val == 0)
 }
 
 pub fn lit_eq(a: &lit, b: &lit) -> Option<bool> {
-    compare_const_vals(&lit_to_const(a), &lit_to_const(b)).map(|&val| val == 0)
+    compare_const_vals(&lit_to_const(a), &lit_to_const(b)).map_move(|val| val == 0)
 }
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index 0dfad430f4d..42bc435a58a 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -393,7 +393,7 @@ impl<'self> LanguageItemCollector<'self> {
             return;    // Didn't match.
         }
 
-        let item_index = self.item_refs.find(&value).map(|x| **x);
+        let item_index = self.item_refs.find(&value).map_move(|x| *x);
         // prevent borrow checker from considering   ^~~~~~~~~~~
         // self to be borrowed (annoying)
 
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 0387f344796..b3961630490 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -607,9 +607,9 @@ impl Liveness {
         match expr.node {
           expr_path(_) => {
             let def = self.tcx.def_map.get_copy(&expr.id);
-            moves::moved_variable_node_id_from_def(def).map(
-                |rdef| self.variable(*rdef, expr.span)
-            )
+            do moves::moved_variable_node_id_from_def(def).map_move |rdef| {
+                self.variable(rdef, expr.span)
+            }
           }
           _ => None
         }
@@ -623,9 +623,9 @@ impl Liveness {
                                  -> Option<Variable> {
         match self.tcx.def_map.find(&node_id) {
           Some(&def) => {
-            moves::moved_variable_node_id_from_def(def).map(
-                |rdef| self.variable(*rdef, span)
-            )
+            do moves::moved_variable_node_id_from_def(def).map_move |rdef| {
+                self.variable(rdef, span)
+            }
           }
           None => {
             self.tcx.sess.span_bug(
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 2d121209118..4da22be4428 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -111,7 +111,7 @@ impl RegionMaps {
     pub fn opt_encl_scope(&self, id: ast::NodeId) -> Option<ast::NodeId> {
         //! Returns the narrowest scope that encloses `id`, if any.
 
-        self.scope_map.find(&id).map(|&x| *x)
+        self.scope_map.find(&id).map_move(|x| *x)
     }
 
     pub fn encl_scope(&self, id: ast::NodeId) -> ast::NodeId {
@@ -579,8 +579,7 @@ impl DetermineRpCtxt {
     /// the new variance is joined with the old variance.
     pub fn add_rp(&mut self, id: ast::NodeId, variance: region_variance) {
         assert!(id != 0);
-        let old_variance = self.region_paramd_items.find(&id).
-                                map_consume(|x| *x);
+        let old_variance = self.region_paramd_items.find(&id).map_move(|x| *x);
         let joined_variance = match old_variance {
           None => variance,
           Some(v) => join_variance(v, variance)
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 625dcd5d9cc..da0ba1558c9 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -3358,7 +3358,7 @@ impl Resolver {
                   // item, it's ok
                   match def {
                     def_ty_param(did, _)
-                        if self.def_map.find(&did.node).map_consume(|x| *x)
+                        if self.def_map.find(&did.node).map_move(|x| *x)
                             == Some(def_typaram_binder(item_id)) => {
                       // ok
                     }
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 2efed8f36d7..dcaa141cbc2 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -92,7 +92,7 @@ pub use middle::trans::context::task_llcx;
 static task_local_insn_key: local_data::Key<@~[&'static str]> = &local_data::Key;
 
 pub fn with_insn_ctxt(blk: &fn(&[&'static str])) {
-    let opt = local_data::get(task_local_insn_key, |k| k.map(|&k| *k));
+    let opt = local_data::get(task_local_insn_key, |k| k.map_move(|k| *k));
     if opt.is_some() {
         blk(*opt.unwrap());
     }
@@ -108,7 +108,7 @@ pub struct _InsnCtxt { _x: () }
 impl Drop for _InsnCtxt {
     fn drop(&self) {
         do local_data::modify(task_local_insn_key) |c| {
-            do c.map_consume |ctx| {
+            do c.map_move |ctx| {
                 let mut ctx = (*ctx).clone();
                 ctx.pop();
                 @ctx
@@ -120,7 +120,7 @@ impl Drop for _InsnCtxt {
 pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
     debug!("new InsnCtxt: %s", s);
     do local_data::modify(task_local_insn_key) |c| {
-        do c.map_consume |ctx| {
+        do c.map_move |ctx| {
             let mut ctx = (*ctx).clone();
             ctx.push(s);
             @ctx
diff --git a/src/librustc/middle/trans/cabi_mips.rs b/src/librustc/middle/trans/cabi_mips.rs
index fe1c288d177..f5fb68a7057 100644
--- a/src/librustc/middle/trans/cabi_mips.rs
+++ b/src/librustc/middle/trans/cabi_mips.rs
@@ -159,7 +159,7 @@ fn struct_ty(ty: Type,
              padding: Option<Type>,
              coerce: bool) -> Type {
     let size = ty_size(ty) * 8;
-    let mut fields = padding.map_default(~[], |p| ~[*p]);
+    let mut fields = padding.map_move_default(~[], |p| ~[p]);
 
     if coerce {
         fields = vec::append(fields, coerce_to_int(size));
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index f303e7b8275..240696ec190 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -1010,8 +1010,7 @@ pub fn node_id_type_params(bcx: @mut Block, id: ast::NodeId) -> ~[ty::t] {
 pub fn node_vtables(bcx: @mut Block, id: ast::NodeId)
                  -> Option<typeck::vtable_res> {
     let raw_vtables = bcx.ccx().maps.vtable_map.find(&id);
-    raw_vtables.map(
-        |&vts| resolve_vtables_in_fn_ctxt(bcx.fcx, *vts))
+    raw_vtables.map_move(|vts| resolve_vtables_in_fn_ctxt(bcx.fcx, *vts))
 }
 
 pub fn resolve_vtables_in_fn_ctxt(fcx: &FunctionContext, vts: typeck::vtable_res)
diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs
index 802163583d6..56ba1ae1694 100644
--- a/src/librustc/middle/trans/context.rs
+++ b/src/librustc/middle/trans/context.rs
@@ -241,7 +241,7 @@ impl Drop for CrateContext {
 static task_local_llcx_key: local_data::Key<@ContextRef> = &local_data::Key;
 
 pub fn task_llcx() -> ContextRef {
-    let opt = local_data::get(task_local_llcx_key, |k| k.map(|&k| *k));
+    let opt = local_data::get(task_local_llcx_key, |k| k.map_move(|k| *k));
     *opt.expect("task-local LLVMContextRef wasn't ever set!")
 }
 
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index b67d88c07e1..9be01ef1db9 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -162,7 +162,7 @@ pub fn trans_method_callee(bcx: @mut Block,
                 data: Method(MethodData {
                     llfn: callee_fn.llfn,
                     llself: val,
-                    temp_cleanup: temp_cleanups.head_opt().map(|&v| *v),
+                    temp_cleanup: temp_cleanups.head_opt().map_move(|v| *v),
                     self_ty: node_id_type(bcx, this.id),
                     self_mode: mentry.self_mode,
                 })
@@ -339,7 +339,7 @@ pub fn trans_monomorphized_callee(bcx: @mut Block,
               data: Method(MethodData {
                   llfn: llfn_val,
                   llself: llself_val,
-                  temp_cleanup: temp_cleanups.head_opt().map(|&v| *v),
+                  temp_cleanup: temp_cleanups.head_opt().map_move(|v| *v),
                   self_ty: node_id_type(bcx, base.id),
                   self_mode: mentry.self_mode,
               })
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 3f4db29ef7e..849c35cdd2c 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -3557,7 +3557,7 @@ pub fn def_has_ty_params(def: ast::def) -> bool {
 
 pub fn provided_source(cx: ctxt, id: ast::def_id)
     -> Option<ast::def_id> {
-    cx.provided_method_sources.find(&id).map(|x| **x)
+    cx.provided_method_sources.find(&id).map_move(|x| *x)
 }
 
 pub fn provided_trait_methods(cx: ctxt, id: ast::def_id) -> ~[@Method] {
@@ -3710,8 +3710,9 @@ fn struct_ctor_id(cx: ctxt, struct_did: ast::def_id) -> Option<ast::def_id> {
         Some(&ast_map::node_item(item, _)) => {
             match item.node {
                 ast::item_struct(struct_def, _) => {
-                    struct_def.ctor_id.map(|ctor_id|
-                        ast_util::local_def(*ctor_id))
+                    do struct_def.ctor_id.map_move |ctor_id| {
+                        ast_util::local_def(ctor_id)
+                    }
                 }
                 _ => cx.sess.bug("called struct_ctor_id on non-struct")
             }
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 53853e4fe1a..750bd506f3e 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -621,9 +621,9 @@ fn ty_of_method_or_bare_fn<AC:AstConv,RS:region_scope + Clone + 'static>(
         in_binding_rscope(rscope,
                           RegionParamNames(bound_lifetime_names.clone()));
 
-    let opt_transformed_self_ty = opt_self_info.map(|&self_info| {
+    let opt_transformed_self_ty = do opt_self_info.map_move |self_info| {
         transform_self_ty(this, &rb, self_info)
-    });
+    };
 
     let input_tys = decl.inputs.map(|a| ty_of_arg(this, &rb, a, None));
 
diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index 7caed390601..d8a9350e695 100644
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -158,9 +158,9 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path,
                 None => {
                     fcx.infcx().type_error_message_str_with_expected(pat.span,
                                                        |expected, actual| {
-                                                       expected.map_default(~"", |e| {
+                                                       expected.map_move_default(~"", |e| {
                         fmt!("mismatched types: expected `%s` but found %s",
-                             *e, actual)})},
+                             e, actual)})},
                              Some(expected), ~"a structure pattern",
                              None);
                     fcx.write_error(pat.id);
@@ -201,9 +201,9 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path,
         _ => {
             fcx.infcx().type_error_message_str_with_expected(pat.span,
                                                |expected, actual| {
-                                               expected.map_default(~"", |e| {
+                                               expected.map_move_default(~"", |e| {
                     fmt!("mismatched types: expected `%s` but found %s",
-                         *e, actual)})},
+                         e, actual)})},
                     Some(expected), ~"an enum or structure pattern",
                     None);
             fcx.write_error(pat.id);
@@ -535,9 +535,9 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
                     _ => ty::terr_mismatch
                 };
                 fcx.infcx().type_error_message_str_with_expected(pat.span, |expected, actual| {
-                expected.map_default(~"", |e| {
+                expected.map_move_default(~"", |e| {
                     fmt!("mismatched types: expected `%s` but found %s",
-                                     *e, actual)})}, Some(expected), ~"tuple", Some(&type_error));
+                                     e, actual)})}, Some(expected), ~"tuple", Some(&type_error));
                 fcx.write_error(pat.id);
             }
         }
@@ -584,9 +584,9 @@ pub fn check_pat(pcx: &pat_ctxt, pat: @ast::pat, expected: ty::t) {
               fcx.infcx().type_error_message_str_with_expected(
                   pat.span,
                   |expected, actual| {
-                      expected.map_default(~"", |e| {
+                      expected.map_move_default(~"", |e| {
                           fmt!("mismatched types: expected `%s` but found %s",
-                               *e, actual)})},
+                               e, actual)})},
                   Some(expected),
                   ~"a vector pattern",
                   None);
@@ -642,9 +642,9 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
             fcx.infcx().type_error_message_str_with_expected(
                 span,
                 |expected, actual| {
-                    expected.map_default(~"", |e| {
+                    expected.map_move_default(~"", |e| {
                         fmt!("mismatched types: expected `%s` but found %s",
-                             *e, actual)})},
+                             e, actual)})},
                 Some(expected),
                 fmt!("%s pattern", match pointer_kind {
                     Managed => "an @-box",
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index ea8a11fc7b3..4a4834c9a03 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -364,8 +364,8 @@ pub fn check_fn(ccx: @mut CrateCtxt,
                 |br| ty::re_free(ty::FreeRegion {scope_id: body.id,
                                                  bound_region: br}));
         let opt_self_info =
-            opt_self_info.map(
-                |si| SelfInfo {self_ty: opt_self_ty.unwrap(), ..*si});
+            opt_self_info.map_move(
+                |si| SelfInfo {self_ty: opt_self_ty.unwrap(), .. si});
         (isr, opt_self_info, fn_sig)
     };
 
@@ -536,7 +536,7 @@ pub fn check_method(ccx: @mut CrateCtxt,
 {
     let method_def_id = local_def(method.id);
     let method_ty = ty::method(ccx.tcx, method_def_id);
-    let opt_self_info = method_ty.transformed_self_ty.map(|&ty| {
+    let opt_self_info = method_ty.transformed_self_ty.map_move(|ty| {
         SelfInfo {self_ty: ty,
                   self_id: method.self_id,
                   span: method.explicit_self.span}
@@ -557,7 +557,7 @@ pub fn check_no_duplicate_fields(tcx: ty::ctxt,
 
     for p in fields.iter() {
         let (id, sp) = *p;
-        let orig_sp = field_names.find(&id).map_consume(|x| *x);
+        let orig_sp = field_names.find(&id).map_move(|x| *x);
         match orig_sp {
             Some(orig_sp) => {
                 tcx.sess.span_err(sp, fmt!("Duplicate field name %s in record type declaration",
@@ -601,7 +601,7 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
         check_bare_fn(ccx, decl, body, it.id, None);
       }
       ast::item_impl(_, _, _, ref ms) => {
-        let rp = ccx.tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
+        let rp = ccx.tcx.region_paramd_items.find(&it.id).map_move(|x| *x);
         debug!("item_impl %s with id %d rp %?",
                ccx.tcx.sess.str_of(it.ident), it.id, rp);
         for m in ms.iter() {
@@ -1877,8 +1877,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         for field in ast_fields.iter() {
             let mut expected_field_type = ty::mk_err();
 
-            let pair = class_field_map.find(&field.ident).
-                                       map_consume(|x| *x);
+            let pair = class_field_map.find(&field.ident).map_move(|x| *x);
             match pair {
                 None => {
                     tcx.sess.span_err(
@@ -1962,7 +1961,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         if class_id.crate == ast::LOCAL_CRATE {
             region_parameterized =
                 tcx.region_paramd_items.find(&class_id.node).
-                    map_consume(|x| *x);
+                    map_move(|x| *x);
             match tcx.items.find(&class_id.node) {
                 Some(&ast_map::node_item(@ast::item {
                         node: ast::item_struct(_, ref generics),
@@ -2050,7 +2049,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         let raw_type;
         if enum_id.crate == ast::LOCAL_CRATE {
             region_parameterized =
-                tcx.region_paramd_items.find(&enum_id.node).map_consume(|x| *x);
+                tcx.region_paramd_items.find(&enum_id.node).map_move(|x| *x);
             match tcx.items.find(&enum_id.node) {
                 Some(&ast_map::node_item(@ast::item {
                         node: ast::item_enum(_, ref generics),
diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs
index 2685055bd84..cb4827104b6 100644
--- a/src/librustc/middle/typeck/check/regionmanip.rs
+++ b/src/librustc/middle/typeck/check/regionmanip.rs
@@ -40,9 +40,9 @@ pub fn replace_bound_regions_in_fn_sig(
 
     debug!("replace_bound_regions_in_fn_sig(self_ty=%?, fn_sig=%s, \
             all_tys=%?)",
-           opt_self_ty.map(|&t| ppaux::ty_to_str(tcx, t)),
+           opt_self_ty.map(|t| ppaux::ty_to_str(tcx, *t)),
            ppaux::fn_sig_to_str(tcx, fn_sig),
-           all_tys.map(|&t| ppaux::ty_to_str(tcx, t)));
+           all_tys.map(|t| ppaux::ty_to_str(tcx, *t)));
     let _i = indenter();
 
     let isr = do create_bound_region_mapping(tcx, isr, all_tys) |br| {
@@ -52,12 +52,12 @@ pub fn replace_bound_regions_in_fn_sig(
     let new_fn_sig = ty::fold_sig(fn_sig, |t| {
         replace_bound_regions(tcx, isr, t)
     });
-    let new_self_ty = opt_self_ty.map(|&t| replace_bound_regions(tcx, isr, t));
+    let new_self_ty = opt_self_ty.map(|t| replace_bound_regions(tcx, isr, *t));
 
     debug!("result of replace_bound_regions_in_fn_sig: \
             new_self_ty=%?, \
             fn_sig=%s",
-           new_self_ty.map(|&t| ppaux::ty_to_str(tcx, t)),
+           new_self_ty.map(|t| ppaux::ty_to_str(tcx, *t)),
            ppaux::fn_sig_to_str(tcx, &new_fn_sig));
 
     return (isr, new_self_ty, new_fn_sig);
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index 2bef2c08bb2..907a076b1a1 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -198,7 +198,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
                             trait_id: ast::NodeId)
 {
     let tcx = ccx.tcx;
-    let region_paramd = tcx.region_paramd_items.find(&trait_id).map(|&x| *x);
+    let region_paramd = tcx.region_paramd_items.find(&trait_id).map_move(|x| *x);
     match tcx.items.get_copy(&trait_id) {
         ast_map::node_item(@ast::item {
             node: ast::item_trait(ref generics, _, ref ms),
@@ -817,7 +817,7 @@ pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt,
 
 pub fn convert(ccx: &CrateCtxt, it: &ast::item) {
     let tcx = ccx.tcx;
-    let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
+    let rp = tcx.region_paramd_items.find(&it.id).map_move(|x| *x);
     debug!("convert: item %s with id %d rp %?",
            tcx.sess.str_of(it.ident), it.id, rp);
     match it.node {
@@ -1020,7 +1020,7 @@ pub fn trait_def_of_item(ccx: &CrateCtxt, it: &ast::item) -> @ty::TraitDef {
       Some(&def) => return def,
       _ => {}
     }
-    let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
+    let rp = tcx.region_paramd_items.find(&it.id).map_move(|x| *x);
     match it.node {
         ast::item_trait(ref generics, _, _) => {
             let self_ty = ty::mk_self(tcx, def_id);
@@ -1049,7 +1049,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
       Some(&tpt) => return tpt,
       _ => {}
     }
-    let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
+    let rp = tcx.region_paramd_items.find(&it.id).map_move(|x| *x);
     match it.node {
       ast::item_static(ref t, _, _) => {
         let typ = ccx.to_ty(&empty_rscope, t);
@@ -1086,7 +1086,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
           None => { }
         }
 
-        let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
+        let rp = tcx.region_paramd_items.find(&it.id).map_move(|x| *x);
         let region_parameterization =
             RegionParameterization::from_variance_and_generics(rp, generics);
         let tpt = {
diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs
index 854ee835cc7..7fa7daf6149 100644
--- a/src/librustc/middle/typeck/infer/mod.rs
+++ b/src/librustc/middle/typeck/infer/mod.rs
@@ -716,12 +716,13 @@ impl InferCtxt {
                                                 err: Option<&ty::type_err>) {
         debug!("hi! expected_ty = %?, actual_ty = %s", expected_ty, actual_ty);
 
-        let error_str = err.map_default(~"", |t_err|
-                         fmt!(" (%s)",
-                              ty::type_err_to_str(self.tcx, *t_err)));
-        let resolved_expected = expected_ty.map(|&e_ty|
-                                                { self.resolve_type_vars_if_possible(e_ty) });
-        if !resolved_expected.map_default(false, |&e| { ty::type_is_error(e) }) {
+        let error_str = do err.map_move_default(~"") |t_err| {
+            fmt!(" (%s)", ty::type_err_to_str(self.tcx, t_err))
+        };
+        let resolved_expected = do expected_ty.map_move |e_ty| {
+            self.resolve_type_vars_if_possible(e_ty)
+        };
+        if !resolved_expected.map_move_default(false, |e| { ty::type_is_error(e) }) {
             match resolved_expected {
                 None => self.tcx.sess.span_err(sp,
                             fmt!("%s%s", mk_msg(None, actual_ty), error_str)),
diff --git a/src/librustc/rustc.rs b/src/librustc/rustc.rs
index 46414a7a5e2..222433787f0 100644
--- a/src/librustc/rustc.rs
+++ b/src/librustc/rustc.rs
@@ -249,13 +249,12 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
 
     let sopts = build_session_options(binary, matches, demitter);
     let sess = build_session(sopts, demitter);
-    let odir = getopts::opt_maybe_str(matches, "out-dir");
-    let odir = odir.map(|o| Path(*o));
-    let ofile = getopts::opt_maybe_str(matches, "o");
-    let ofile = ofile.map(|o| Path(*o));
+    let odir = getopts::opt_maybe_str(matches, "out-dir").map_move(|o| Path(o));
+    let ofile = getopts::opt_maybe_str(matches, "o").map_move(|o| Path(o));
     let cfg = build_configuration(sess, binary, &input);
-    let pretty = getopts::opt_default(matches, "pretty", "normal").map(
-                    |a| parse_pretty(sess, *a));
+    let pretty = do getopts::opt_default(matches, "pretty", "normal").map_move |a| {
+        parse_pretty(sess, a)
+    };
     match pretty {
       Some::<pp_mode>(ppm) => {
         pretty_print_input(sess, cfg, &input, ppm);
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index d387bbea592..3598eb7c0fb 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -140,7 +140,7 @@ fn config_from_opts(
     let result = result::Ok(config);
     let result = do result.chain |config| {
         let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
-        let output_dir = output_dir.map(|s| Path(*s));
+        let output_dir = output_dir.map_move(|s| Path(s));
         result::Ok(Config {
             output_dir: output_dir.unwrap_or_default(config.output_dir.clone()),
             .. config
@@ -148,8 +148,8 @@ fn config_from_opts(
     };
     let result = do result.chain |config| {
         let output_format = getopts::opt_maybe_str(matches, opt_output_format());
-        do output_format.map_default(result::Ok(config.clone())) |output_format| {
-            do parse_output_format(*output_format).chain |output_format| {
+        do output_format.map_move_default(result::Ok(config.clone())) |output_format| {
+            do parse_output_format(output_format).chain |output_format| {
                 result::Ok(Config {
                     output_format: output_format,
                     .. config.clone()
@@ -160,8 +160,8 @@ fn config_from_opts(
     let result = do result.chain |config| {
         let output_style =
             getopts::opt_maybe_str(matches, opt_output_style());
-        do output_style.map_default(result::Ok(config.clone())) |output_style| {
-            do parse_output_style(*output_style).chain |output_style| {
+        do output_style.map_move_default(result::Ok(config.clone())) |output_style| {
+            do parse_output_style(output_style).chain |output_style| {
                 result::Ok(Config {
                     output_style: output_style,
                     .. config.clone()
diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs
index 684b4e9d198..0d7ec34243d 100644
--- a/src/librustdoc/tystr_pass.rs
+++ b/src/librustdoc/tystr_pass.rs
@@ -260,9 +260,9 @@ fn fold_impl(
                 }, _) => {
                     let bounds = pprust::generics_to_str(generics, extract::interner());
                     let bounds = if bounds.is_empty() { None } else { Some(bounds) };
-                    let trait_types = opt_trait_type.map_default(~[], |p| {
+                    let trait_types = do opt_trait_type.map_default(~[]) |p| {
                         ~[pprust::path_to_str(&p.path, extract::interner())]
-                    });
+                    };
                     (bounds,
                      trait_types,
                      Some(pprust::ty_to_str(
diff --git a/src/librusti/rusti.rs b/src/librusti/rusti.rs
index 86290ea65b5..bbcff4e2a35 100644
--- a/src/librusti/rusti.rs
+++ b/src/librusti/rusti.rs
@@ -203,7 +203,7 @@ fn run(mut program: ~Program, binary: ~str, lib_search_paths: ~[~str],
                 }
             }
         }
-        result = do blk.expr.map_consume |e| {
+        result = do blk.expr.map_move |e| {
             do with_pp(intr) |pp, _| { pprust::print_expr(pp, e); }
         };
     }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index fbc471c0ae0..3484a5e7d6e 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -238,7 +238,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
         let len_buckets = self.buckets.len();
         let bucket = self.buckets[idx].take();
 
-        let value = do bucket.map_consume |bucket| {
+        let value = do bucket.map_move |bucket| {
             bucket.value
         };
 
@@ -479,7 +479,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
 impl<K: Hash + Eq, V: Clone> HashMap<K, V> {
     /// Like `find`, but returns a copy of the value.
     pub fn find_copy(&self, k: &K) -> Option<V> {
-        self.find(k).map_consume(|v| (*v).clone())
+        self.find(k).map_move(|v| (*v).clone())
     }
 
     /// Like `get`, but returns a copy of the value.
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index e86f4d7a85e..47e8eac27f0 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -674,7 +674,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
                     Some((y, y_val))
                 }
             }
-        }).map_consume(|(x, _)| x)
+        }).map_move(|(x, _)| x)
     }
 
     #[inline]
@@ -689,7 +689,7 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
                     Some((y, y_val))
                 }
             }
-        }).map_consume(|(x, _)| x)
+        }).map_move(|(x, _)| x)
     }
 }
 
@@ -1383,7 +1383,7 @@ impl<'self, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for
                     return Some(x)
                 }
             }
-            match self.iter.next().map_consume(|x| (self.f)(x)) {
+            match self.iter.next().map_move(|x| (self.f)(x)) {
                 None => return self.backiter.chain_mut_ref(|it| it.next()),
                 next => self.frontiter = next,
             }
@@ -1415,7 +1415,7 @@ impl<'self,
                     y => return y
                 }
             }
-            match self.iter.next_back().map_consume(|x| (self.f)(x)) {
+            match self.iter.next_back().map_move(|x| (self.f)(x)) {
                 None => return self.frontiter.chain_mut_ref(|it| it.next_back()),
                 next => self.backiter = next,
             }
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index ea1bddcdb4b..e43ff65da5e 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -208,6 +208,12 @@ impl<T> Option<T> {
         match *self { Some(ref mut x) => Some(f(x)), None => None }
     }
 
+    /// Applies a function to the contained value or returns a default
+    #[inline]
+    pub fn map_default<'a, U>(&'a self, def: U, f: &fn(&'a T) -> U) -> U {
+        match *self { None => def, Some(ref t) => f(t) }
+    }
+
     /// Maps a `Some` value from one type to another by a mutable reference,
     /// or returns a default value.
     #[inline]
@@ -218,21 +224,15 @@ impl<T> Option<T> {
     /// As `map`, but consumes the option and gives `f` ownership to avoid
     /// copying.
     #[inline]
-    pub fn map_consume<U>(self, f: &fn(v: T) -> U) -> Option<U> {
-        match self { None => None, Some(v) => Some(f(v)) }
-    }
-
-    /// Applies a function to the contained value or returns a default
-    #[inline]
-    pub fn map_default<'a, U>(&'a self, def: U, f: &fn(&'a T) -> U) -> U {
-        match *self { None => def, Some(ref t) => f(t) }
+    pub fn map_move<U>(self, f: &fn(T) -> U) -> Option<U> {
+        match self { Some(x) => Some(f(x)), None => None }
     }
 
     /// As `map_default`, but consumes the option and gives `f`
     /// ownership to avoid copying.
     #[inline]
-    pub fn map_consume_default<U>(self, def: U, f: &fn(v: T) -> U) -> U {
-        match self { None => def, Some(v) => f(v) }
+    pub fn map_move_default<U>(self, def: U, f: &fn(T) -> U) -> U {
+        match self { None => def, Some(t) => f(t) }
     }
 
     /// Take the value out of the option, leaving a `None` in its place.
@@ -241,18 +241,18 @@ impl<T> Option<T> {
         util::replace(self, None)
     }
 
-    /// As `map_consume`, but swaps a None into the original option rather
+    /// As `map_move`, but swaps a None into the original option rather
     /// than consuming it by-value.
     #[inline]
     pub fn take_map<U>(&mut self, blk: &fn(T) -> U) -> Option<U> {
-        self.take().map_consume(blk)
+        self.take().map_move(blk)
     }
 
-    /// As `map_consume_default`, but swaps a None into the original option
+    /// As `map_move_default`, but swaps a None into the original option
     /// rather than consuming it by-value.
     #[inline]
     pub fn take_map_default<U> (&mut self, def: U, blk: &fn(T) -> U) -> U {
-        self.take().map_consume_default(def, blk)
+        self.take().map_move_default(def, blk)
     }
 
     /// Apply a function to the contained value or do nothing.
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index b0e1f35b4a0..f246a61a4d5 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -498,9 +498,7 @@ pub fn self_exe_path() -> Option<Path> {
         }
     }
 
-    do load_self().map |pth| {
-        Path(*pth).dir_path()
-    }
+    load_self().map_move(|path| Path(path).dir_path())
 }
 
 
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index e62ae3885eb..3e429c6116d 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -407,14 +407,14 @@ mod tests {
 
     #[test]
     pub fn test_impl_map_move() {
-        assert_eq!(Ok::<~str, ~str>(~"a").map_move(|x| x + ~"b"), Ok(~"ab"));
-        assert_eq!(Err::<~str, ~str>(~"a").map_move(|x| x + ~"b"), Err(~"a"));
+        assert_eq!(Ok::<~str, ~str>(~"a").map_move(|x| x + "b"), Ok(~"ab"));
+        assert_eq!(Err::<~str, ~str>(~"a").map_move(|x| x + "b"), Err(~"a"));
     }
 
     #[test]
     pub fn test_impl_map_err_move() {
-        assert_eq!(Ok::<~str, ~str>(~"a").map_err_move(|x| x + ~"b"), Ok(~"a"));
-        assert_eq!(Err::<~str, ~str>(~"a").map_err_move(|x| x + ~"b"), Err(~"ab"));
+        assert_eq!(Ok::<~str, ~str>(~"a").map_err_move(|x| x + "b"), Ok(~"a"));
+        assert_eq!(Err::<~str, ~str>(~"a").map_err_move(|x| x + "b"), Err(~"ab"));
     }
 
     #[test]
diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index a060059f5fc..0cf223f3029 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -159,7 +159,7 @@ impl<T> ChanOne<T> {
                     // Port is blocked. Wake it up.
                     let recvr = BlockedTask::cast_from_uint(task_as_state);
                     if do_resched {
-                        do recvr.wake().map_consume |woken_task| {
+                        do recvr.wake().map_move |woken_task| {
                             Scheduler::run_task(woken_task);
                         };
                     } else {
@@ -381,7 +381,7 @@ impl<T> Drop for ChanOne<T> {
                     // The port is blocked waiting for a message we will never send. Wake it.
                     assert!((*this.packet()).payload.is_none());
                     let recvr = BlockedTask::cast_from_uint(task_as_state);
-                    do recvr.wake().map_consume |woken_task| {
+                    do recvr.wake().map_move |woken_task| {
                         Scheduler::run_task(woken_task);
                     };
                 }
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 3372c13b877..d90ad07650d 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -402,7 +402,7 @@ impl KillHandle {
                     || {
                         // Prefer to check tombstones that were there first,
                         // being "more fair" at the expense of tail-recursion.
-                        others.take().map_consume_default(true, |f| f()) && {
+                        others.take().map_move_default(true, |f| f()) && {
                             let mut inner = this.take().unwrap();
                             (!inner.any_child_failed) &&
                                 inner.child_tombstones.take_map_default(true, |f| f())
@@ -424,7 +424,7 @@ impl KillHandle {
                     let others = Cell::new(other_tombstones); // :(
                     || {
                         // Prefer fairness to tail-recursion, as in above case.
-                        others.take().map_consume_default(true, |f| f()) &&
+                        others.take().map_move_default(true, |f| f()) &&
                             f.take()()
                     }
                 }
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 1a75f2569b5..c2c12c6e3c0 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -325,7 +325,7 @@ impl Scheduler {
     /// As enqueue_task, but with the possibility for the blocked task to
     /// already have been killed.
     pub fn enqueue_blocked_task(&mut self, blocked_task: BlockedTask) {
-        do blocked_task.wake().map_consume |task| {
+        do blocked_task.wake().map_move |task| {
             self.enqueue_task(task);
         };
     }
@@ -533,7 +533,7 @@ impl Scheduler {
                 sched.enqueue_blocked_task(last_task);
             }
         };
-        opt.map_consume(Local::put);
+        opt.map_move(Local::put);
     }
 
     // The primary function for changing contexts. In the current
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index b4057b85cbf..a327b687a75 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -1849,7 +1849,7 @@ impl<'self> StrSlice<'self> for &'self str {
         } else {
             self.matches_index_iter(needle)
                 .next()
-                .map_consume(|(start, _end)| start)
+                .map_move(|(start, _end)| start)
         }
     }
 
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 527b20b0e90..7486a78837c 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -500,7 +500,7 @@ impl RuntimeGlue {
             OldTask(ptr) => rt::rust_task_kill_other(ptr),
             NewTask(handle) => {
                 let mut handle = handle;
-                do handle.kill().map_consume |killed_task| {
+                do handle.kill().map_move |killed_task| {
                     let killed_task = Cell::new(killed_task);
                     do Local::borrow::<Scheduler, ()> |sched| {
                         sched.enqueue_task(killed_task.take());
@@ -682,7 +682,7 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
         // Child task runs this code.
 
         // If child data is 'None', the enlist is vacuously successful.
-        let enlist_success = do child_data.take().map_consume_default(true) |child_data| {
+        let enlist_success = do child_data.take().map_move_default(true) |child_data| {
             let child_data = Cell::new(child_data); // :(
             do Local::borrow::<Task, bool> |me| {
                 let (child_tg, ancestors, is_main) = child_data.take();
@@ -854,7 +854,7 @@ fn spawn_raw_oldsched(mut opts: TaskOpts, f: ~fn()) {
             // Even if the below code fails to kick the child off, we must
             // send Something on the notify channel.
 
-            let notifier = notify_chan.map_consume(|c| AutoNotify(c));
+            let notifier = notify_chan.map_move(|c| AutoNotify(c));
 
             if enlist_many(OldTask(child), &child_arc, &mut ancestors) {
                 let group = @@mut Taskgroup(child_arc, ancestors, is_main, notifier);
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 84e6544f780..ba167fe6714 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -888,7 +888,7 @@ pub fn new_sctable_internal() -> SCTable {
 // fetch the SCTable from TLS, create one if it doesn't yet exist.
 pub fn get_sctable() -> @mut SCTable {
     static sctable_key: local_data::Key<@@mut SCTable> = &local_data::Key;
-    match local_data::get(sctable_key, |k| k.map(|&k| *k)) {
+    match local_data::get(sctable_key, |k| k.map_move(|k| *k)) {
         None => {
             let new_table = @@mut new_sctable_internal();
             local_data::set(sctable_key,new_table);
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index d39cb2f507c..9edd41152f7 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -83,7 +83,7 @@ impl AttrMetaMethods for MetaItem {
     }
 
     pub fn name_str_pair(&self) -> Option<(@str, @str)> {
-        self.value_str().map_consume(|s| (self.name(), s))
+        self.value_str().map_move(|s| (self.name(), s))
     }
 }
 
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 8b501436641..2b6cb91a5df 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -192,7 +192,7 @@ fn print_maybe_styled(msg: &str, color: term::attr::Attr) {
     let stderr = io::stderr();
 
     if stderr.get_type() == io::Screen {
-        let t = match local_data::get(tls_terminal, |v| v.map_consume(|&k|k)) {
+        let t = match local_data::get(tls_terminal, |v| v.map_move(|k| *k)) {
             None => {
                 let t = term::Terminal::new(stderr);
                 let tls = @match t {
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 6ed5ca3e402..efaf6b8e001 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -479,7 +479,7 @@ impl <K: Eq + Hash + IterBytes + 'static, V: 'static> MapChain<K,V>{
             ConsMapChain(ref map,_) => map
         };
         // strip one layer of indirection off the pointer.
-        map.find(key).map(|r| {**r})
+        map.find(key).map_move(|r| {*r})
     }
 
     // insert the binding into the top-level map
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index c373a389488..d81dca005b0 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -591,7 +591,7 @@ impl AstBuilder for @ExtCtxt {
 
     fn expr_if(&self, span: span,
                cond: @ast::expr, then: @ast::expr, els: Option<@ast::expr>) -> @ast::expr {
-        let els = els.map(|x| self.expr_block(self.block_expr(*x)));
+        let els = els.map_move(|x| self.expr_block(self.block_expr(x)));
         self.expr(span, ast::expr_if(cond, self.block_expr(then), els))
     }
 
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 7ffed13940e..0a5bc000720 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -417,7 +417,7 @@ fn noop_fold_stmt(s: &stmt_, fld: @ast_fold) -> Option<stmt_> {
 fn noop_fold_arm(a: &arm, fld: @ast_fold) -> arm {
     arm {
         pats: a.pats.map(|x| fld.fold_pat(*x)),
-        guard: a.guard.map(|x| fld.fold_expr(*x)),
+        guard: a.guard.map_move(|x| fld.fold_expr(x)),
         body: fld.fold_block(&a.body),
     }
 }
@@ -429,7 +429,7 @@ pub fn noop_fold_pat(p: &pat_, fld: @ast_fold) -> pat_ {
             pat_ident(
                 binding_mode,
                 fld.fold_path(pth),
-                sub.map(|x| fld.fold_pat(*x))
+                sub.map_move(|x| fld.fold_pat(x))
             )
         }
         pat_lit(e) => pat_lit(fld.fold_expr(e)),
@@ -459,7 +459,7 @@ pub fn noop_fold_pat(p: &pat_, fld: @ast_fold) -> pat_ {
         pat_vec(ref before, ref slice, ref after) => {
             pat_vec(
                 before.map(|x| fld.fold_pat(*x)),
-                slice.map(|x| fld.fold_pat(*x)),
+                slice.map_move(|x| fld.fold_pat(x)),
                 after.map(|x| fld.fold_pat(*x))
             )
         }
@@ -551,7 +551,7 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
             expr_if(
                 fld.fold_expr(cond),
                 fld.fold_block(tr),
-                fl.map(|x| fld.fold_expr(*x))
+                fl.map_move(|x| fld.fold_expr(x))
             )
         }
         expr_while(cond, ref body) => {
@@ -565,7 +565,7 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
         expr_loop(ref body, opt_ident) => {
             expr_loop(
                 fld.fold_block(body),
-                opt_ident.map(|x| fld.fold_ident(*x))
+                opt_ident.map_move(|x| fld.fold_ident(x))
             )
         }
         expr_match(expr, ref arms) => {
@@ -608,13 +608,13 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
         expr_path(ref pth) => expr_path(fld.fold_path(pth)),
         expr_self => expr_self,
         expr_break(ref opt_ident) => {
-            expr_break(opt_ident.map(|x| fld.fold_ident(*x)))
+            expr_break(opt_ident.map_move(|x| fld.fold_ident(x)))
         }
         expr_again(ref opt_ident) => {
-            expr_again(opt_ident.map(|x| fld.fold_ident(*x)))
+            expr_again(opt_ident.map_move(|x| fld.fold_ident(x)))
         }
         expr_ret(ref e) => {
-            expr_ret(e.map(|x| fld.fold_expr(*x)))
+            expr_ret(e.map_move(|x| fld.fold_expr(x)))
         }
         expr_log(lv, e) => {
             expr_log(
@@ -634,7 +634,7 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
             expr_struct(
                 fld.fold_path(path),
                 fields.map(|x| fold_field(*x)),
-                maybe_expr.map(|x| fld.fold_expr(*x))
+                maybe_expr.map_move(|x| fld.fold_expr(x))
             )
         },
         expr_paren(ex) => expr_paren(fld.fold_expr(ex))
@@ -731,7 +731,7 @@ fn noop_fold_variant(v: &variant_, fld: @ast_fold) -> variant_ {
                 fold_variant_arg(/*bad*/ (*x).clone())
             })
         }
-        struct_variant_kind(struct_def) => {
+        struct_variant_kind(ref struct_def) => {
             kind = struct_variant_kind(@ast::struct_def {
                 fields: struct_def.fields.iter()
                     .transform(|f| fld.fold_struct_field(*f)).collect(),
@@ -776,7 +776,7 @@ fn noop_fold_local(l: @Local, fld: @ast_fold) -> @Local {
         is_mutbl: l.is_mutbl,
         ty: fld.fold_ty(&l.ty),
         pat: fld.fold_pat(l.pat),
-        init: l.init.map(|e| fld.fold_expr(*e)),
+        init: l.init.map_move(|e| fld.fold_expr(e)),
         id: fld.new_id(l.id),
         span: fld.new_span(l.span),
     }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index a0932729930..4902c4587ac 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1313,7 +1313,7 @@ impl Parser {
 
         // If the path might have bounds on it, they should be parsed before
         // the parameters, e.g. module::TraitName:B1+B2<T>
-        before_tps.map_consume(|callback| callback());
+        before_tps.map_move(|callback| callback());
 
         // Parse the (obsolete) trailing region parameter, if any, which will
         // be written "foo/&x"
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 39668e5c8b2..fd491c1e890 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -486,7 +486,7 @@ fn mk_fresh_ident_interner() -> @ident_interner {
 pub fn get_ident_interner() -> @ident_interner {
     static key: local_data::Key<@@::parse::token::ident_interner> =
         &local_data::Key;
-    match local_data::get(key, |k| k.map(|&k| *k)) {
+    match local_data::get(key, |k| k.map_move(|k| *k)) {
         Some(interner) => *interner,
         None => {
             let interner = mk_fresh_ident_interner();
-- 
cgit 1.4.1-3-g733a5


From 19e17f54a02e484f1ab4fd809caa0aaf3f3d14bc Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Sun, 4 Aug 2013 16:30:51 -0700
Subject: std: removed option.take_map{,_default}

---
 src/libstd/option.rs  | 14 --------------
 src/libstd/rt/kill.rs | 10 +++++-----
 2 files changed, 5 insertions(+), 19 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index e43ff65da5e..66b30d8dd03 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -241,20 +241,6 @@ impl<T> Option<T> {
         util::replace(self, None)
     }
 
-    /// As `map_move`, but swaps a None into the original option rather
-    /// than consuming it by-value.
-    #[inline]
-    pub fn take_map<U>(&mut self, blk: &fn(T) -> U) -> Option<U> {
-        self.take().map_move(blk)
-    }
-
-    /// As `map_move_default`, but swaps a None into the original option
-    /// rather than consuming it by-value.
-    #[inline]
-    pub fn take_map_default<U> (&mut self, def: U, blk: &fn(T) -> U) -> U {
-        self.take().map_move_default(def, blk)
-    }
-
     /// Apply a function to the contained value or do nothing.
     /// Returns true if the contained value was mutated.
     pub fn mutate(&mut self, f: &fn(T) -> T) -> bool {
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index d90ad07650d..789c7531eca 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -405,7 +405,7 @@ impl KillHandle {
                         others.take().map_move_default(true, |f| f()) && {
                             let mut inner = this.take().unwrap();
                             (!inner.any_child_failed) &&
-                                inner.child_tombstones.take_map_default(true, |f| f())
+                                inner.child_tombstones.take().map_move_default(true, |f| f())
                         }
                     }
                 }
@@ -493,7 +493,7 @@ impl Death {
         { use util; util::ignore(group); }
 
         // Step 1. Decide if we need to collect child failures synchronously.
-        do self.on_exit.take_map |on_exit| {
+        do self.on_exit.take().map_move |on_exit| {
             if success {
                 // We succeeded, but our children might not. Need to wait for them.
                 let mut inner = self.kill_handle.take_unwrap().unwrap();
@@ -501,7 +501,7 @@ impl Death {
                     success = false;
                 } else {
                     // Lockless access to tombstones protected by unwrap barrier.
-                    success = inner.child_tombstones.take_map_default(true, |f| f());
+                    success = inner.child_tombstones.take().map_move_default(true, |f| f());
                 }
             }
             on_exit(success);
@@ -510,12 +510,12 @@ impl Death {
         // Step 2. Possibly alert possibly-watching parent to failure status.
         // Note that as soon as parent_handle goes out of scope, the parent
         // can successfully unwrap its handle and collect our reported status.
-        do self.watching_parent.take_map |mut parent_handle| {
+        do self.watching_parent.take().map_move |mut parent_handle| {
             if success {
                 // Our handle might be None if we had an exit callback, and
                 // already unwrapped it. But 'success' being true means no
                 // child failed, so there's nothing to do (see below case).
-                do self.kill_handle.take_map |own_handle| {
+                do self.kill_handle.take().map_move |own_handle| {
                     own_handle.reparent_children_to(&mut parent_handle);
                 };
             } else {
-- 
cgit 1.4.1-3-g733a5


From eb6143257dd5a6848be4e073fc756ae705156241 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 5 Aug 2013 12:14:03 -0700
Subject: std::rt: 2MB stacks again

---
 src/libstd/rt/task.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/libstd')

diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index e732ef67b5b..2da44c2f332 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -326,7 +326,7 @@ impl Drop for Task {
 impl Coroutine {
 
     pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Coroutine {
-        static MIN_STACK_SIZE: uint = 3000000; // XXX: Too much stack
+        static MIN_STACK_SIZE: uint = 2000000; // XXX: Too much stack
 
         let start = Coroutine::build_start_wrapper(start);
         let mut stack = stack_pool.take_segment(MIN_STACK_SIZE);
-- 
cgit 1.4.1-3-g733a5


From f82da818a7ea94f4bbb1a1ea15073b51805fd582 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 5 Aug 2013 12:43:33 -0700
Subject: std::rt: Pull RUST_MIN_STACK from the environment

---
 src/libstd/rt/env.rs  | 28 ++++++++++++++++++++++++++++
 src/libstd/rt/mod.rs  |  1 +
 src/libstd/rt/task.rs |  6 +++---
 3 files changed, 32 insertions(+), 3 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libstd/rt/env.rs b/src/libstd/rt/env.rs
index 1d7ff173149..6e671742fb6 100644
--- a/src/libstd/rt/env.rs
+++ b/src/libstd/rt/env.rs
@@ -10,7 +10,12 @@
 
 //! Runtime environment settings
 
+use from_str::FromStr;
 use libc::{size_t, c_char, c_int};
+use option::{Some, None};
+use os;
+
+// OLD RT stuff
 
 pub struct Environment {
     /// The number of threads to use by default
@@ -47,3 +52,26 @@ pub fn get() -> &Environment {
 extern {
     fn rust_get_rt_env() -> &Environment;
 }
+
+// NEW RT stuff
+
+// Note that these are all accessed without any synchronization.
+// They are expected to be initialized once then left alone.
+
+static mut MIN_STACK: uint = 2000000;
+
+pub fn init() {
+    unsafe {
+        match os::getenv("RUST_MIN_STACK") {
+            Some(s) => match FromStr::from_str(s) {
+                Some(i) => MIN_STACK = i,
+                None => ()
+            },
+            None => ()
+        }
+    }
+}
+
+pub fn min_stack() -> uint {
+    unsafe { MIN_STACK }
+}
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 760ca8a9ada..5b22eace56f 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -212,6 +212,7 @@ pub fn init(argc: int, argv: **u8, crate_map: *u8) {
     // Need to propagate the unsafety to `start`.
     unsafe {
         args::init(argc, argv);
+        env::init();
         logging::init(crate_map);
         rust_update_gc_metadata(crate_map);
     }
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 2da44c2f332..aa6d51a480b 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -20,6 +20,7 @@ use libc::{c_void, uintptr_t};
 use ptr;
 use prelude::*;
 use option::{Option, Some, None};
+use rt::env;
 use rt::kill::Death;
 use rt::local::Local;
 use rt::logging::StdErrLogger;
@@ -326,10 +327,9 @@ impl Drop for Task {
 impl Coroutine {
 
     pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Coroutine {
-        static MIN_STACK_SIZE: uint = 2000000; // XXX: Too much stack
-
+        let stack_size = env::min_stack();
         let start = Coroutine::build_start_wrapper(start);
-        let mut stack = stack_pool.take_segment(MIN_STACK_SIZE);
+        let mut stack = stack_pool.take_segment(stack_size);
         let initial_context = Context::new(start, &mut stack);
         Coroutine {
             current_stack_segment: stack,
-- 
cgit 1.4.1-3-g733a5


From ae1ed4fd78273502153083f1514a1fcd7c929886 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 5 Aug 2013 13:10:08 -0700
Subject: std: Allow spawners to specify stack size

---
 src/libstd/rt/local.rs   | 11 ++++++-----
 src/libstd/rt/mod.rs     |  7 +++----
 src/libstd/rt/sched.rs   | 14 +++++++-------
 src/libstd/rt/task.rs    | 37 +++++++++++++++++++++++--------------
 src/libstd/rt/test.rs    | 15 +++++++--------
 src/libstd/task/mod.rs   | 12 ++++++++----
 src/libstd/task/spawn.rs | 14 +++++++-------
 7 files changed, 61 insertions(+), 49 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs
index 131507196b1..7154066e7b7 100644
--- a/src/libstd/rt/local.rs
+++ b/src/libstd/rt/local.rs
@@ -126,6 +126,7 @@ impl Local for IoFactoryObject {
 
 #[cfg(test)]
 mod test {
+    use option::None;
     use unstable::run_in_bare_thread;
     use rt::test::*;
     use super::*;
@@ -137,7 +138,7 @@ mod test {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
@@ -149,11 +150,11 @@ mod test {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
-            let task = ~Task::new_root(&mut sched.stack_pool, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
@@ -166,7 +167,7 @@ mod test {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
             Local::put(task);
 
             unsafe {
@@ -182,7 +183,7 @@ mod test {
         do run_in_bare_thread {
             local_ptr::init_tls_key();
             let mut sched = ~new_test_uv_sched();
-            let task = ~Task::new_root(&mut sched.stack_pool, || {});
+            let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
             Local::put(task);
 
             let res = do Local::borrow::<Task,bool> |_task| {
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 5b22eace56f..147c75e5c41 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -331,8 +331,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
         // In the case where we do not use a main_thread scheduler we
         // run the main task in one of our threads.
 
-        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool,
-                                            main.take());
+        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool, None, main.take());
         main_task.death.on_exit = Some(on_exit.take());
         let main_task_cell = Cell::new(main_task);
 
@@ -352,7 +351,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
         let sched_cell = Cell::new(sched);
         let thread = do Thread::start {
             let mut sched = sched_cell.take();
-            let bootstrap_task = ~do Task::new_root(&mut sched.stack_pool) || {
+            let bootstrap_task = ~do Task::new_root(&mut sched.stack_pool, None) || {
                 rtdebug!("boostraping a non-primary scheduler");
             };
             sched.bootstrap(bootstrap_task);
@@ -369,7 +368,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
         let mut main_sched = main_sched.unwrap();
 
         let home = Sched(main_sched.make_handle());
-        let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool,
+        let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool, None,
                                                   home, main.take());
         main_task.death.on_exit = Some(on_exit.take());
         rtdebug!("boostrapping main_task");
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index c2c12c6e3c0..990e1a4a3de 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -833,7 +833,7 @@ mod test {
             let mut sched = ~new_test_uv_sched();
             let sched_handle = sched.make_handle();
 
-            let mut task = ~do Task::new_root_homed(&mut sched.stack_pool,
+            let mut task = ~do Task::new_root_homed(&mut sched.stack_pool, None,
                                                 Sched(sched_handle)) {
                 unsafe { *task_ran_ptr = true };
                 assert!(Task::on_appropriate_sched());
@@ -893,21 +893,21 @@ mod test {
             //   3) task not homed, sched requeues
             //   4) task not home, send home
 
-            let task1 = ~do Task::new_root_homed(&mut special_sched.stack_pool,
+            let task1 = ~do Task::new_root_homed(&mut special_sched.stack_pool, None,
                                                  Sched(t1_handle)) || {
                 rtassert!(Task::on_appropriate_sched());
             };
             rtdebug!("task1 id: **%u**", borrow::to_uint(task1));
 
-            let task2 = ~do Task::new_root(&mut normal_sched.stack_pool) {
+            let task2 = ~do Task::new_root(&mut normal_sched.stack_pool, None) {
                 rtassert!(Task::on_appropriate_sched());
             };
 
-            let task3 = ~do Task::new_root(&mut normal_sched.stack_pool) {
+            let task3 = ~do Task::new_root(&mut normal_sched.stack_pool, None) {
                 rtassert!(Task::on_appropriate_sched());
             };
 
-            let task4 = ~do Task::new_root_homed(&mut special_sched.stack_pool,
+            let task4 = ~do Task::new_root_homed(&mut special_sched.stack_pool, None,
                                                  Sched(t4_handle)) {
                 rtassert!(Task::on_appropriate_sched());
             };
@@ -923,7 +923,7 @@ mod test {
             let port = Cell::new(port);
             let chan = Cell::new(chan);
 
-            let normal_task = ~do Task::new_root(&mut normal_sched.stack_pool) {
+            let normal_task = ~do Task::new_root(&mut normal_sched.stack_pool, None) {
                 rtdebug!("*about to submit task2*");
                 Scheduler::run_task(task2.take());
                 rtdebug!("*about to submit task4*");
@@ -938,7 +938,7 @@ mod test {
 
             rtdebug!("normal task: %u", borrow::to_uint(normal_task));
 
-            let special_task = ~do Task::new_root(&mut special_sched.stack_pool) {
+            let special_task = ~do Task::new_root(&mut special_sched.stack_pool, None) {
                 rtdebug!("*about to submit task1*");
                 Scheduler::run_task(task1.take());
                 rtdebug!("*about to submit task3*");
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index aa6d51a480b..364439a4526 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -86,12 +86,13 @@ impl Task {
 
     // A helper to build a new task using the dynamically found
     // scheduler and task. Only works in GreenTask context.
-    pub fn build_homed_child(f: ~fn(), home: SchedHome) -> ~Task {
+    pub fn build_homed_child(stack_size: Option<uint>, f: ~fn(), home: SchedHome) -> ~Task {
         let f = Cell::new(f);
         let home = Cell::new(home);
         do Local::borrow::<Task, ~Task> |running_task| {
             let mut sched = running_task.sched.take_unwrap();
             let new_task = ~running_task.new_child_homed(&mut sched.stack_pool,
+                                                         stack_size,
                                                          home.take(),
                                                          f.take());
             running_task.sched = Some(sched);
@@ -99,25 +100,26 @@ impl Task {
         }
     }
 
-    pub fn build_child(f: ~fn()) -> ~Task {
-        Task::build_homed_child(f, AnySched)
+    pub fn build_child(stack_size: Option<uint>, f: ~fn()) -> ~Task {
+        Task::build_homed_child(stack_size, f, AnySched)
     }
 
-    pub fn build_homed_root(f: ~fn(), home: SchedHome) -> ~Task {
+    pub fn build_homed_root(stack_size: Option<uint>, f: ~fn(), home: SchedHome) -> ~Task {
         let f = Cell::new(f);
         let home = Cell::new(home);
         do Local::borrow::<Task, ~Task> |running_task| {
             let mut sched = running_task.sched.take_unwrap();
             let new_task = ~Task::new_root_homed(&mut sched.stack_pool,
-                                                    home.take(),
-                                                    f.take());
+                                                 stack_size,
+                                                 home.take(),
+                                                 f.take());
             running_task.sched = Some(sched);
             new_task
         }
     }
 
-    pub fn build_root(f: ~fn()) -> ~Task {
-        Task::build_homed_root(f, AnySched)
+    pub fn build_root(stack_size: Option<uint>, f: ~fn()) -> ~Task {
+        Task::build_homed_root(stack_size, f, AnySched)
     }
 
     pub fn new_sched_task() -> Task {
@@ -138,17 +140,20 @@ impl Task {
     }
 
     pub fn new_root(stack_pool: &mut StackPool,
+                    stack_size: Option<uint>,
                     start: ~fn()) -> Task {
-        Task::new_root_homed(stack_pool, AnySched, start)
+        Task::new_root_homed(stack_pool, stack_size, AnySched, start)
     }
 
     pub fn new_child(&mut self,
                      stack_pool: &mut StackPool,
+                     stack_size: Option<uint>,
                      start: ~fn()) -> Task {
-        self.new_child_homed(stack_pool, AnySched, start)
+        self.new_child_homed(stack_pool, stack_size, AnySched, start)
     }
 
     pub fn new_root_homed(stack_pool: &mut StackPool,
+                          stack_size: Option<uint>,
                           home: SchedHome,
                           start: ~fn()) -> Task {
         Task {
@@ -161,7 +166,7 @@ impl Task {
             death: Death::new(),
             destroyed: false,
             name: None,
-            coroutine: Some(Coroutine::new(stack_pool, start)),
+            coroutine: Some(Coroutine::new(stack_pool, stack_size, start)),
             sched: None,
             task_type: GreenTask(Some(~home))
         }
@@ -169,6 +174,7 @@ impl Task {
 
     pub fn new_child_homed(&mut self,
                            stack_pool: &mut StackPool,
+                           stack_size: Option<uint>,
                            home: SchedHome,
                            start: ~fn()) -> Task {
         Task {
@@ -182,7 +188,7 @@ impl Task {
             death: self.death.new_child(),
             destroyed: false,
             name: None,
-            coroutine: Some(Coroutine::new(stack_pool, start)),
+            coroutine: Some(Coroutine::new(stack_pool, stack_size, start)),
             sched: None,
             task_type: GreenTask(Some(~home))
         }
@@ -326,8 +332,11 @@ impl Drop for Task {
 
 impl Coroutine {
 
-    pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Coroutine {
-        let stack_size = env::min_stack();
+    pub fn new(stack_pool: &mut StackPool, stack_size: Option<uint>, start: ~fn()) -> Coroutine {
+        let stack_size = match stack_size {
+            Some(size) => size,
+            None => env::min_stack()
+        };
         let start = Coroutine::build_start_wrapper(start);
         let mut stack = stack_pool.take_segment(stack_size);
         let initial_context = Context::new(start, &mut stack);
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 8b5215ae969..792ea5eb33f 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -57,7 +57,7 @@ pub fn run_in_newsched_task_core(f: ~fn()) {
         exit_handle.take().send(Shutdown);
         rtassert!(exit_status);
     };
-    let mut task = ~Task::new_root(&mut sched.stack_pool, f);
+    let mut task = ~Task::new_root(&mut sched.stack_pool, None, f);
     task.death.on_exit = Some(on_exit);
 
     sched.bootstrap(task);
@@ -190,8 +190,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
 
             rtassert!(exit_status);
         };
-        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool,
-                                        f.take());
+        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool, None, f.take());
         main_task.death.on_exit = Some(on_exit);
 
         let mut threads = ~[];
@@ -209,7 +208,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
 
         while !scheds.is_empty() {
             let mut sched = scheds.pop();
-            let bootstrap_task = ~do Task::new_root(&mut sched.stack_pool) || {
+            let bootstrap_task = ~do Task::new_root(&mut sched.stack_pool, None) || {
                 rtdebug!("bootstrapping non-primary scheduler");
             };
             let bootstrap_task_cell = Cell::new(bootstrap_task);
@@ -232,12 +231,12 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
 
 /// Test tasks will abort on failure instead of unwinding
 pub fn spawntask(f: ~fn()) {
-    Scheduler::run_task(Task::build_child(f));
+    Scheduler::run_task(Task::build_child(None, f));
 }
 
 /// Create a new task and run it right now. Aborts on failure
 pub fn spawntask_later(f: ~fn()) {
-    Scheduler::run_task_later(Task::build_child(f));
+    Scheduler::run_task_later(Task::build_child(None, f));
 }
 
 pub fn spawntask_random(f: ~fn()) {
@@ -259,7 +258,7 @@ pub fn spawntask_try(f: ~fn()) -> Result<(),()> {
     let chan = Cell::new(chan);
     let on_exit: ~fn(bool) = |exit_status| chan.take().send(exit_status);
 
-    let mut new_task = Task::build_root(f);
+    let mut new_task = Task::build_root(None, f);
     new_task.death.on_exit = Some(on_exit);
 
     Scheduler::run_task(new_task);
@@ -285,7 +284,7 @@ pub fn spawntask_thread(f: ~fn()) -> Thread {
 pub fn with_test_task(blk: ~fn(~Task) -> ~Task) {
     do run_in_bare_thread {
         let mut sched = ~new_test_uv_sched();
-        let task = blk(~Task::new_root(&mut sched.stack_pool, ||{}));
+        let task = blk(~Task::new_root(&mut sched.stack_pool, None, ||{}));
         cleanup_task(task);
     }
 }
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index 225a4b8cfd2..4b5543b8186 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -142,7 +142,8 @@ pub struct TaskOpts {
     indestructible: bool,
     notify_chan: Option<Chan<TaskResult>>,
     name: Option<~str>,
-    sched: SchedOpts
+    sched: SchedOpts,
+    stack_size: Option<uint>
 }
 
 /**
@@ -197,7 +198,8 @@ impl TaskBuilder {
                 indestructible: self.opts.indestructible,
                 notify_chan: notify_chan,
                 name: name,
-                sched: self.opts.sched
+                sched: self.opts.sched,
+                stack_size: self.opts.stack_size
             },
             gen_body: gen_body,
             can_not_copy: None,
@@ -351,7 +353,8 @@ impl TaskBuilder {
             indestructible: x.opts.indestructible,
             notify_chan: notify_chan,
             name: name,
-            sched: x.opts.sched
+            sched: x.opts.sched,
+            stack_size: x.opts.stack_size
         };
         let f = match gen_body {
             Some(gen) => {
@@ -422,7 +425,8 @@ pub fn default_task_opts() -> TaskOpts {
         name: None,
         sched: SchedOpts {
             mode: DefaultScheduler,
-        }
+        },
+        stack_size: None
     }
 }
 
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 7486a78837c..2d0a2d98e9f 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -713,9 +713,9 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
     let mut task = unsafe {
         if opts.sched.mode != SingleThreaded {
             if opts.watched {
-                Task::build_child(child_wrapper)
+                Task::build_child(opts.stack_size, child_wrapper)
             } else {
-                Task::build_root(child_wrapper)
+                Task::build_root(opts.stack_size, child_wrapper)
             }
         } else {
             // Creating a 1:1 task:thread ...
@@ -736,16 +736,16 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
 
             // Pin the new task to the new scheduler
             let new_task = if opts.watched {
-                Task::build_homed_child(child_wrapper, Sched(new_sched_handle))
+                Task::build_homed_child(opts.stack_size, child_wrapper, Sched(new_sched_handle))
             } else {
-                Task::build_homed_root(child_wrapper, Sched(new_sched_handle))
+                Task::build_homed_root(opts.stack_size, child_wrapper, Sched(new_sched_handle))
             };
 
             // Create a task that will later be used to join with the new scheduler
             // thread when it is ready to terminate
             let (thread_port, thread_chan) = oneshot();
             let thread_port_cell = Cell::new(thread_port);
-            let join_task = do Task::build_child() {
+            let join_task = do Task::build_child(None) {
                 rtdebug!("running join task");
                 let thread_port = thread_port_cell.take();
                 let thread: Thread = thread_port.recv();
@@ -762,8 +762,8 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
                 let mut orig_sched_handle = orig_sched_handle_cell.take();
                 let join_task = join_task_cell.take();
 
-                let bootstrap_task = ~do Task::new_root(&mut new_sched.stack_pool) || {
-                    rtdebug!("bootstrapping a 1:1 scheduler");
+                let bootstrap_task = ~do Task::new_root(&mut new_sched.stack_pool, None) || {
+                    rtdebug!("boostrapping a 1:1 scheduler");
                 };
                 new_sched.bootstrap(bootstrap_task);
 
-- 
cgit 1.4.1-3-g733a5


From ce95b01014391f29a655d165d9e6d31449ceb835 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 6 Aug 2013 14:32:30 -0700
Subject: Disable linked failure tests

The implementation currently contains a race that leads to segfaults.
---
 doc/tutorial-tasks.md                     | 16 ++++++++--------
 src/libextra/arc.rs                       |  1 +
 src/libextra/sync.rs                      |  2 ++
 src/libstd/rt/kill.rs                     |  6 ++++++
 src/libstd/task/mod.rs                    | 19 +++++++++++++++++++
 src/test/run-fail/extern-fail.rs          |  1 +
 src/test/run-fail/linked-failure.rs       |  1 +
 src/test/run-fail/linked-failure2.rs      |  1 +
 src/test/run-fail/linked-failure3.rs      |  1 +
 src/test/run-fail/linked-failure4.rs      |  1 +
 src/test/run-fail/spawnfail.rs            |  1 +
 src/test/run-fail/task-comm-recv-block.rs |  1 +
 src/test/run-pass/issue-3168.rs           |  1 +
 src/test/run-pass/lots-a-fail.rs          |  1 +
 src/test/run-pass/send-iloop.rs           |  1 +
 src/test/run-pass/task-killjoin-rsrc.rs   |  1 +
 src/test/run-pass/task-killjoin.rs        |  1 +
 17 files changed, 48 insertions(+), 8 deletions(-)

(limited to 'src/libstd')

diff --git a/doc/tutorial-tasks.md b/doc/tutorial-tasks.md
index d9e4b9b399d..d190c332e66 100644
--- a/doc/tutorial-tasks.md
+++ b/doc/tutorial-tasks.md
@@ -424,7 +424,7 @@ there is no way to "catch" the exception.
 All tasks are, by default, _linked_ to each other. That means that the fates
 of all tasks are intertwined: if one fails, so do all the others.
 
-~~~
+~~~{.xfail-test .linked-failure}
 # use std::task::spawn;
 # use std::task;
 # fn do_some_work() { loop { task::yield() } }
@@ -447,7 +447,7 @@ pattern-match on a result to check whether it's an `Ok` result with an `int`
 field (representing a successful result) or an `Err` result (representing
 termination with an error).
 
-~~~
+~~~{.xfail-test .linked-failure}
 # use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
@@ -490,7 +490,7 @@ proceed). Hence, you will need different _linked failure modes_.
 By default, task failure is _bidirectionally linked_, which means that if
 either task fails, it kills the other one.
 
-~~~
+~~~{.xfail-test .linked-failure}
 # use std::task;
 # use std::comm::oneshot;
 # fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
@@ -512,7 +512,7 @@ function `task::try`, which we saw previously, uses `spawn_supervised`
 internally, with additional logic to wait for the child task to finish
 before returning. Hence:
 
-~~~
+~~~{.xfail-test .linked-failure}
 # use std::comm::{stream, Chan, Port};
 # use std::comm::oneshot;
 # use std::task::{spawn, try};
@@ -543,7 +543,7 @@ also fail.
 Supervised task failure propagates across multiple generations even if
 an intermediate generation has already exited:
 
-~~~
+~~~{.xfail-test .linked-failure}
 # use std::task;
 # use std::comm::oneshot;
 # fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
@@ -563,7 +563,7 @@ fail!();  // Will kill grandchild even if child has already exited
 Finally, tasks can be configured to not propagate failure to each
 other at all, using `task::spawn_unlinked` for _isolated failure_.
 
-~~~
+~~~{.xfail-test .linked-failure}
 # use std::task;
 # fn random() -> uint { 100 }
 # fn sleep_for(i: uint) { for _ in range(0, i) { task::yield() } }
@@ -591,7 +591,7 @@ that repeatedly receives a `uint` message, converts it to a string, and sends
 the string in response.  The child terminates when it receives `0`.
 Here is the function that implements the child task:
 
-~~~~
+~~~{.xfail-test .linked-failure}
 # use extra::comm::DuplexStream;
 # use std::uint;
 fn stringifier(channel: &DuplexStream<~str, uint>) {
@@ -614,7 +614,7 @@ response itself is simply the stringified version of the received value,
 
 Here is the code for the parent task:
 
-~~~~
+~~~{.xfail-test .linked-failure}
 # use std::task::spawn;
 # use std::uint;
 # use extra::comm::DuplexStream;
diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
index cb4468f48ec..17f4cbbd152 100644
--- a/src/libextra/arc.rs
+++ b/src/libextra/arc.rs
@@ -611,6 +611,7 @@ mod tests {
             }
         }
     }
+
     #[test] #[should_fail] #[ignore(cfg(windows))]
     fn test_arc_condvar_poison() {
         unsafe {
diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs
index 63e371899a9..4172c715adb 100644
--- a/src/libextra/sync.rs
+++ b/src/libextra/sync.rs
@@ -935,6 +935,7 @@ mod tests {
         // child task must have finished by the time try returns
         do m.lock { }
     }
+    #[ignore(reason = "linked failure")]
     #[test] #[ignore(cfg(windows))]
     fn test_mutex_killed_cond() {
         // Getting killed during cond wait must not corrupt the mutex while
@@ -961,6 +962,7 @@ mod tests {
             assert!(!woken);
         }
     }
+    #[ignore(reason = "linked failure")]
     #[test] #[ignore(cfg(windows))]
     fn test_mutex_killed_broadcast() {
         use std::unstable::finally::Finally;
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 789c7531eca..fbc9d1d2445 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -614,6 +614,7 @@ mod test {
     // Test cases don't care about the spare killed flag.
     fn make_kill_handle() -> KillHandle { let (h,_) = KillHandle::new(); h }
 
+    #[ignore(reason = "linked failure")]
     #[test]
     fn no_tombstone_success() {
         do run_in_newsched_task {
@@ -819,6 +820,7 @@ mod test {
         }
     }
 
+    #[ignore(reason = "linked failure")]
     #[test]
     fn block_and_get_killed() {
         do with_test_task |mut task| {
@@ -830,6 +832,7 @@ mod test {
         }
     }
 
+    #[ignore(reason = "linked failure")]
     #[test]
     fn block_already_killed() {
         do with_test_task |mut task| {
@@ -839,6 +842,7 @@ mod test {
         }
     }
 
+    #[ignore(reason = "linked failure")]
     #[test]
     fn block_unkillably_and_get_killed() {
         do with_test_task |mut task| {
@@ -856,6 +860,7 @@ mod test {
         }
     }
 
+    #[ignore(reason = "linked failure")]
     #[test]
     fn block_on_pipe() {
         // Tests the "killable" path of casting to/from uint.
@@ -869,6 +874,7 @@ mod test {
         }
     }
 
+    #[ignore(reason = "linked failure")]
     #[test]
     fn block_unkillably_on_pipe() {
         // Tests the "indestructible" path of casting to/from uint.
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index 4b5543b8186..2e0c9c1d1ad 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -659,6 +659,7 @@ pub unsafe fn rekillable<U>(f: &fn() -> U) -> U {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_kill_unkillable_task() {
     use rt::test::*;
@@ -679,6 +680,7 @@ fn test_kill_unkillable_task() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_kill_rekillable_task() {
     use rt::test::*;
@@ -720,6 +722,7 @@ fn test_cant_dup_task_builder() {
 #[cfg(test)]
 fn block_forever() { let (po, _ch) = stream::<()>(); po.recv(); }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_unlinked_unsup_no_fail_down() { // grandchild sends on a port
     use rt::test::run_in_newsched_task;
@@ -738,6 +741,7 @@ fn test_spawn_unlinked_unsup_no_fail_down() { // grandchild sends on a port
         po.recv();
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_unlinked_unsup_no_fail_up() { // child unlinked fails
     use rt::test::run_in_newsched_task;
@@ -745,6 +749,7 @@ fn test_spawn_unlinked_unsup_no_fail_up() { // child unlinked fails
         do spawn_unlinked { fail!(); }
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_unlinked_sup_no_fail_up() { // child unlinked fails
     use rt::test::run_in_newsched_task;
@@ -754,6 +759,7 @@ fn test_spawn_unlinked_sup_no_fail_up() { // child unlinked fails
         do 16.times { task::yield(); }
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_unlinked_sup_fail_down() {
     use rt::test::run_in_newsched_task;
@@ -766,6 +772,7 @@ fn test_spawn_unlinked_sup_fail_down() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_linked_sup_fail_up() { // child fails; parent fails
     use rt::test::run_in_newsched_task;
@@ -786,6 +793,7 @@ fn test_spawn_linked_sup_fail_up() { // child fails; parent fails
         assert!(result.is_err());
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_linked_sup_fail_down() { // parent fails; child fails
     use rt::test::run_in_newsched_task;
@@ -802,6 +810,7 @@ fn test_spawn_linked_sup_fail_down() { // parent fails; child fails
         assert!(result.is_err());
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_linked_unsup_fail_up() { // child fails; parent fails
     use rt::test::run_in_newsched_task;
@@ -814,6 +823,7 @@ fn test_spawn_linked_unsup_fail_up() { // child fails; parent fails
         assert!(result.is_err());
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_linked_unsup_fail_down() { // parent fails; child fails
     use rt::test::run_in_newsched_task;
@@ -826,6 +836,7 @@ fn test_spawn_linked_unsup_fail_down() { // parent fails; child fails
         assert!(result.is_err());
     }
 }
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_linked_unsup_default_opts() { // parent fails; child fails
     use rt::test::run_in_newsched_task;
@@ -844,6 +855,7 @@ fn test_spawn_linked_unsup_default_opts() { // parent fails; child fails
 // A couple bonus linked failure tests - testing for failure propagation even
 // when the middle task exits successfully early before kill signals are sent.
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_failure_propagate_grandchild() {
     use rt::test::run_in_newsched_task;
@@ -860,6 +872,7 @@ fn test_spawn_failure_propagate_grandchild() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_failure_propagate_secondborn() {
     use rt::test::run_in_newsched_task;
@@ -876,6 +889,7 @@ fn test_spawn_failure_propagate_secondborn() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_failure_propagate_nephew_or_niece() {
     use rt::test::run_in_newsched_task;
@@ -892,6 +906,7 @@ fn test_spawn_failure_propagate_nephew_or_niece() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_linked_sup_propagate_sibling() {
     use rt::test::run_in_newsched_task;
@@ -1195,6 +1210,7 @@ fn test_avoid_copying_the_body_unlinked() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test]
 #[ignore(cfg(windows))]
 #[should_fail]
@@ -1230,6 +1246,7 @@ fn test_unkillable() {
     po.recv();
 }
 
+#[ignore(reason = "linked failure")]
 #[test]
 #[ignore(cfg(windows))]
 #[should_fail]
@@ -1296,6 +1313,7 @@ fn test_simple_newsched_spawn() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_spawn_watched() {
     use rt::test::run_in_newsched_task;
@@ -1318,6 +1336,7 @@ fn test_spawn_watched() {
     }
 }
 
+#[ignore(reason = "linked failure")]
 #[test] #[ignore(cfg(windows))]
 fn test_indestructible() {
     use rt::test::run_in_newsched_task;
diff --git a/src/test/run-fail/extern-fail.rs b/src/test/run-fail/extern-fail.rs
index a281e986364..a65db3ee515 100644
--- a/src/test/run-fail/extern-fail.rs
+++ b/src/test/run-fail/extern-fail.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // error-pattern:explicit failure
 // Testing that runtime failure doesn't cause callbacks to abort abnormally.
 // Instead the failure will be delivered after the callbacks return.
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 41a9d7ddcea..52dfb8aef13 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -10,6 +10,7 @@
 // except according to those terms.
 
 
+// xfail-test linked failure
 // error-pattern:1 == 2
 extern mod extra;
 
diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs
index 0269e395986..d4049f6753e 100644
--- a/src/test/run-fail/linked-failure2.rs
+++ b/src/test/run-fail/linked-failure2.rs
@@ -10,6 +10,7 @@
 // except according to those terms.
 
 
+// xfail-test linked failure
 // error-pattern:fail
 
 use std::comm;
diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs
index 1203f74322f..f40eae20bc0 100644
--- a/src/test/run-fail/linked-failure3.rs
+++ b/src/test/run-fail/linked-failure3.rs
@@ -10,6 +10,7 @@
 // except according to those terms.
 
 
+// xfail-test linked failure
 // error-pattern:fail
 
 use std::comm;
diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs
index 766b43f211f..94e41f1ae68 100644
--- a/src/test/run-fail/linked-failure4.rs
+++ b/src/test/run-fail/linked-failure4.rs
@@ -9,6 +9,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // error-pattern:1 == 2
 
 use std::comm;
diff --git a/src/test/run-fail/spawnfail.rs b/src/test/run-fail/spawnfail.rs
index de085a6f3ad..12dab8e25b7 100644
--- a/src/test/run-fail/spawnfail.rs
+++ b/src/test/run-fail/spawnfail.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // xfail-win32
 // error-pattern:explicit
 extern mod extra;
diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs
index 8302b96ca3e..bd51ce38ec0 100644
--- a/src/test/run-fail/task-comm-recv-block.rs
+++ b/src/test/run-fail/task-comm-recv-block.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // error-pattern:goodfail
 
 use std::comm;
diff --git a/src/test/run-pass/issue-3168.rs b/src/test/run-pass/issue-3168.rs
index 609849bffb4..f4e2a9f36a0 100644
--- a/src/test/run-pass/issue-3168.rs
+++ b/src/test/run-pass/issue-3168.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // xfail-fast
 // xfail-win32 #7999
 
diff --git a/src/test/run-pass/lots-a-fail.rs b/src/test/run-pass/lots-a-fail.rs
index cec0a7a756c..13296131236 100644
--- a/src/test/run-pass/lots-a-fail.rs
+++ b/src/test/run-pass/lots-a-fail.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // xfail-win32 leaks
 extern mod extra;
 
diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs
index e27f35d1851..a647e5849a8 100644
--- a/src/test/run-pass/send-iloop.rs
+++ b/src/test/run-pass/send-iloop.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // xfail-win32
 extern mod extra;
 
diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs
index c811e548f3f..b8a1aa433a3 100644
--- a/src/test/run-pass/task-killjoin-rsrc.rs
+++ b/src/test/run-pass/task-killjoin-rsrc.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // xfail-win32
 
 // A port of task-killjoin to use a class with a dtor to manage
diff --git a/src/test/run-pass/task-killjoin.rs b/src/test/run-pass/task-killjoin.rs
index c94e00251d2..5382ac77671 100644
--- a/src/test/run-pass/task-killjoin.rs
+++ b/src/test/run-pass/task-killjoin.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test linked failure
 // xfail-win32
 
 // Create a task that is supervised by another task, join the supervised task
-- 
cgit 1.4.1-3-g733a5


From 85aaa44bec2a87f8df290d4f9b3f7350de50d067 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 5 Aug 2013 00:47:04 -0700
Subject: Turn on the new runtime

---
 src/libstd/unstable/lang.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/libstd')

diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs
index e0c4950b38e..98c0fe254b6 100644
--- a/src/libstd/unstable/lang.rs
+++ b/src/libstd/unstable/lang.rs
@@ -135,7 +135,7 @@ pub fn start(main: *u8, argc: int, argv: **c_char,
     use os;
 
     unsafe {
-        let use_old_rt = os::getenv("RUST_NEWRT").is_none();
+        let use_old_rt = os::getenv("RUST_OLDRT").is_some();
         if use_old_rt {
             return rust_start(main as *c_void, argc as c_int, argv,
                               crate_map as *c_void) as int;
-- 
cgit 1.4.1-3-g733a5


From ffb670ffcd69ed8e7cd13a7f06375ede752349e2 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 29 Jul 2013 01:12:41 -0700
Subject: Add initial support for a new formatting syntax

The new macro is available under the name ifmt! (only an intermediate name)
---
 src/libstd/either.rs                        |   2 +-
 src/libstd/fmt/mod.rs                       | 368 ++++++++++++
 src/libstd/fmt/parse.rs                     | 896 ++++++++++++++++++++++++++++
 src/libstd/fmt/rt.rs                        |  62 ++
 src/libstd/rt/io/mem.rs                     |   2 +-
 src/libstd/std.rs                           |   3 +
 src/libsyntax/ext/base.rs                   |   2 +
 src/libsyntax/ext/expand.rs                 |   4 +-
 src/libsyntax/ext/ifmt.rs                   | 720 ++++++++++++++++++++++
 src/libsyntax/syntax.rs                     |   1 +
 src/test/compile-fail/ifmt-bad-arg.rs       |  74 +++
 src/test/compile-fail/ifmt-bad-plural.rs    |  14 +
 src/test/compile-fail/ifmt-bad-select.rs    |  14 +
 src/test/compile-fail/ifmt-unimpl.rs        |  14 +
 src/test/compile-fail/ifmt-unknown-trait.rs |  14 +
 src/test/run-pass/ifmt.rs                   |  71 +++
 16 files changed, 2258 insertions(+), 3 deletions(-)
 create mode 100644 src/libstd/fmt/mod.rs
 create mode 100644 src/libstd/fmt/parse.rs
 create mode 100644 src/libstd/fmt/rt.rs
 create mode 100644 src/libsyntax/ext/ifmt.rs
 create mode 100644 src/test/compile-fail/ifmt-bad-arg.rs
 create mode 100644 src/test/compile-fail/ifmt-bad-plural.rs
 create mode 100644 src/test/compile-fail/ifmt-bad-select.rs
 create mode 100644 src/test/compile-fail/ifmt-unimpl.rs
 create mode 100644 src/test/compile-fail/ifmt-unknown-trait.rs
 create mode 100644 src/test/run-pass/ifmt.rs

(limited to 'src/libstd')

diff --git a/src/libstd/either.rs b/src/libstd/either.rs
index cfaef550c6f..bb74d9b3ec4 100644
--- a/src/libstd/either.rs
+++ b/src/libstd/either.rs
@@ -24,7 +24,7 @@ use vec;
 use vec::{OwnedVector, ImmutableVector};
 
 /// `Either` is a type that represents one of two alternatives
-#[deriving(Clone, Eq)]
+#[deriving(Clone, Eq, IterBytes)]
 pub enum Either<L, R> {
     Left(L),
     Right(R)
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
new file mode 100644
index 00000000000..2b8807b2291
--- /dev/null
+++ b/src/libstd/fmt/mod.rs
@@ -0,0 +1,368 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use prelude::*;
+
+use cast;
+use int;
+use rt::io::Decorator;
+use rt::io::mem::MemWriter;
+use rt::io;
+use str;
+use sys;
+use uint;
+use util;
+use vec;
+
+pub mod parse;
+pub mod rt;
+
+/// A struct to represent both where to emit formatting strings to and how they
+/// should be formatted. A mutable version of this is passed to all formatting
+/// traits.
+pub struct Formatter<'self> {
+    /// Flags for formatting (packed version of rt::Flag)
+    flags: uint,
+    /// Character used as 'fill' whenever there is alignment
+    fill: char,
+    /// Boolean indication of whether the output should be left-aligned
+    alignleft: bool,
+    /// Optionally specified integer width that the output should be
+    width: Option<uint>,
+    /// Optionally specified precision for numeric types
+    precision: Option<uint>,
+
+    /// Output buffer.
+    buf: &'self mut io::Writer,
+
+    priv curarg: vec::VecIterator<'self, Argument<'self>>,
+    priv args: &'self [Argument<'self>],
+}
+
+/// This struct represents the generic "argument" which is taken by the Xprintf
+/// family of functions. It contains a function to format the given value. At
+/// compile time it is ensured that the function and the value have the correct
+/// types, and then this struct is used to canonicalize arguments to one type.
+pub struct Argument<'self> {
+    priv formatter: extern "Rust" fn(&util::Void, &mut Formatter),
+    priv value: &'self util::Void,
+}
+
+#[allow(missing_doc)]
+pub trait Bool { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Char { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Signed { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Unsigned { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Octal { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Binary { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait LowerHex { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait UpperHex { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait String { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Poly { fn fmt(&Self, &mut Formatter); }
+#[allow(missing_doc)]
+pub trait Pointer { fn fmt(&Self, &mut Formatter); }
+
+/// The sprintf function takes a precompiled format string and a list of
+/// arguments, to return the resulting formatted string.
+///
+/// This is currently an unsafe function because the types of all arguments
+/// aren't verified by immediate callers of this function. This currently does
+/// not validate that the correct types of arguments are specified for each
+/// format specifier, nor that each argument itself contains the right function
+/// for formatting the right type value. Because of this, the function is marked
+/// as `unsafe` if this is being called manually.
+///
+/// Thankfully the rust compiler provides the macro `ifmt!` which will perform
+/// all of this validation at compile-time and provides a safe interface for
+/// invoking this function.
+///
+/// # Arguments
+///
+///   * fmts - the precompiled format string to emit.
+///   * args - the list of arguments to the format string. These are only the
+///            positional arguments (not named)
+///
+/// Note that this function assumes that there are enough arguments for the
+/// format string.
+pub unsafe fn sprintf(fmt: &[rt::Piece], args: &[Argument]) -> ~str {
+    let output = MemWriter::new();
+    {
+        let mut formatter = Formatter {
+            flags: 0,
+            width: None,
+            precision: None,
+            // FIXME(#8248): shouldn't need a transmute
+            buf: cast::transmute(&output as &io::Writer),
+            alignleft: false,
+            fill: ' ',
+            args: args,
+            curarg: args.iter(),
+        };
+        for piece in fmt.iter() {
+            formatter.run(piece, None);
+        }
+    }
+    return str::from_bytes_owned(output.inner());
+}
+
+impl<'self> Formatter<'self> {
+    fn run(&mut self, piece: &rt::Piece, cur: Option<&str>) {
+        let setcount = |slot: &mut Option<uint>, cnt: &parse::Count| {
+            match *cnt {
+                parse::CountIs(n) => { *slot = Some(n); }
+                parse::CountImplied => { *slot = None; }
+                parse::CountIsParam(i) => {
+                    let v = self.args[i].value;
+                    unsafe { *slot = Some(*(v as *util::Void as *uint)); }
+                }
+                parse::CountIsNextParam => {
+                    let v = self.curarg.next().unwrap().value;
+                    unsafe { *slot = Some(*(v as *util::Void as *uint)); }
+                }
+            }
+        };
+
+        match *piece {
+            rt::String(s) => { self.buf.write(s.as_bytes()); }
+            rt::CurrentArgument(()) => { self.buf.write(cur.unwrap().as_bytes()); }
+            rt::Argument(ref arg) => {
+                // Fill in the format parameters into the formatter
+                self.fill = arg.format.fill;
+                self.alignleft = arg.format.alignleft;
+                self.flags = arg.format.flags;
+                setcount(&mut self.width, &arg.format.width);
+                setcount(&mut self.precision, &arg.format.precision);
+
+                // Extract the correct argument
+                let value = match arg.position {
+                    rt::ArgumentNext => { *self.curarg.next().unwrap() }
+                    rt::ArgumentIs(i) => self.args[i],
+                };
+
+                // Then actually do some printing
+                match arg.method {
+                    None => { (value.formatter)(value.value, self); }
+                    Some(ref method) => { self.execute(*method, value); }
+                }
+            }
+        }
+    }
+
+    fn execute(&mut self, method: &rt::Method, arg: Argument) {
+        match *method {
+            // Pluralization is selection upon a numeric value specified as the
+            // parameter.
+            rt::Plural(offset, ref selectors, ref default) => {
+                // This is validated at compile-time to be a pointer to a
+                // '&uint' value.
+                let value: &uint = unsafe { cast::transmute(arg.value) };
+                let value = *value;
+
+                // First, attempt to match against explicit values without the
+                // offsetted value
+                for s in selectors.iter() {
+                    match s.selector {
+                        Right(val) if value == val => {
+                            return self.runplural(value, s.result);
+                        }
+                        _ => {}
+                    }
+                }
+
+                // Next, offset the value and attempt to match against the
+                // keyword selectors.
+                let value = value - match offset { Some(i) => i, None => 0 };
+                for s in selectors.iter() {
+                    let run = match s.selector {
+                        Left(parse::Zero) => value == 0,
+                        Left(parse::One) => value == 1,
+                        Left(parse::Two) => value == 2,
+
+                        // XXX: Few/Many should have a user-specified boundary
+                        //      One possible option would be in the function
+                        //      pointer of the 'arg: Argument' struct.
+                        Left(parse::Few) => value < 8,
+                        Left(parse::Many) => value >= 8,
+
+                        Right(*) => false
+                    };
+                    if run {
+                        return self.runplural(value, s.result);
+                    }
+                }
+
+                self.runplural(value, *default);
+            }
+
+            // Select is just a matching against the string specified.
+            rt::Select(ref selectors, ref default) => {
+                // This is validated at compile-time to be a pointer to a
+                // string slice,
+                let value: & &str = unsafe { cast::transmute(arg.value) };
+                let value = *value;
+
+                for s in selectors.iter() {
+                    if s.selector == value {
+                        for piece in s.result.iter() {
+                            self.run(piece, Some(value));
+                        }
+                        return;
+                    }
+                }
+                for piece in default.iter() {
+                    self.run(piece, Some(value));
+                }
+            }
+        }
+    }
+
+    fn runplural(&mut self, value: uint, pieces: &[rt::Piece]) {
+        do uint::to_str_bytes(value, 10) |buf| {
+            let valuestr = str::from_bytes_slice(buf);
+            for piece in pieces.iter() {
+                self.run(piece, Some(valuestr));
+            }
+        }
+    }
+}
+
+/// This is a function which calls are emitted to by the compiler itself to
+/// create the Argument structures that are passed into the `sprintf` function.
+#[doc(hidden)]
+pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter),
+                       t: &'a T) -> Argument<'a> {
+    unsafe {
+        Argument {
+            formatter: cast::transmute(f),
+            value: cast::transmute(t)
+        }
+    }
+}
+
+/// When the compiler determines that the type of an argument *must* be a string
+/// (such as for select), then it invokes this method.
+#[doc(hidden)]
+pub fn argumentstr<'a>(s: &'a &str) -> Argument<'a> {
+    argument(String::fmt, s)
+}
+
+/// When the compiler determines that the type of an argument *must* be a uint
+/// (such as for plural), then it invokes this method.
+#[doc(hidden)]
+pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
+    argument(Unsigned::fmt, s)
+}
+
+// Implementations of the core formatting traits
+
+impl Bool for bool {
+    fn fmt(b: &bool, f: &mut Formatter) {
+        String::fmt(&(if *b {"true"} else {"false"}), f);
+    }
+}
+
+impl<'self> String for &'self str {
+    fn fmt(s: & &'self str, f: &mut Formatter) {
+        // XXX: formatting args
+        f.buf.write(s.as_bytes())
+    }
+}
+
+impl Char for char {
+    fn fmt(c: &char, f: &mut Formatter) {
+        // XXX: formatting args
+        // XXX: shouldn't require an allocation
+        let mut s = ~"";
+        s.push_char(*c);
+        f.buf.write(s.as_bytes());
+    }
+}
+
+impl Signed for int {
+    fn fmt(c: &int, f: &mut Formatter) {
+        // XXX: formatting args
+        do int::to_str_bytes(*c, 10) |buf| {
+            f.buf.write(buf);
+        }
+    }
+}
+
+impl Unsigned for uint {
+    fn fmt(c: &uint, f: &mut Formatter) {
+        // XXX: formatting args
+        do uint::to_str_bytes(*c, 10) |buf| {
+            f.buf.write(buf);
+        }
+    }
+}
+
+impl Octal for uint {
+    fn fmt(c: &uint, f: &mut Formatter) {
+        // XXX: formatting args
+        do uint::to_str_bytes(*c, 8) |buf| {
+            f.buf.write(buf);
+        }
+    }
+}
+
+impl LowerHex for uint {
+    fn fmt(c: &uint, f: &mut Formatter) {
+        // XXX: formatting args
+        do uint::to_str_bytes(*c, 16) |buf| {
+            f.buf.write(buf);
+        }
+    }
+}
+
+impl UpperHex for uint {
+    fn fmt(c: &uint, f: &mut Formatter) {
+        // XXX: formatting args
+        do uint::to_str_bytes(*c, 16) |buf| {
+            let mut local = [0u8, ..16];
+            for (l, &b) in local.mut_iter().zip(buf.iter()) {
+                *l = match b as char {
+                    'a' .. 'f' => (b - 'a' as u8) + 'A' as u8,
+                    _ => b,
+                };
+            }
+            f.buf.write(local.slice_to(buf.len()));
+        }
+    }
+}
+
+impl<T> Poly for T {
+    fn fmt(t: &T, f: &mut Formatter) {
+        // XXX: formatting args
+        let s = sys::log_str(t);
+        f.buf.write(s.as_bytes());
+    }
+}
+
+// n.b. use 'const' to get an implementation for both '*mut' and '*' at the same
+//      time.
+impl<T> Pointer for *const T {
+    fn fmt(t: &*const T, f: &mut Formatter) {
+        // XXX: formatting args
+        f.buf.write("0x".as_bytes());
+        LowerHex::fmt(&(*t as uint), f);
+    }
+}
+
+// If you expected tests to be here, look instead at the run-pass/ifmt.rs test,
+// it's a lot easier than creating all of the rt::Piece structures here.
diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs
new file mode 100644
index 00000000000..673ea1d3fa8
--- /dev/null
+++ b/src/libstd/fmt/parse.rs
@@ -0,0 +1,896 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use prelude::*;
+
+use char;
+use str;
+use iterator;
+
+condition! { pub parse_error: ~str -> (); }
+
+/// A piece is a portion of the format string which represents the next part to
+/// emit. These are emitted as a stream by the `Parser` class.
+#[deriving(Eq)]
+pub enum Piece<'self> {
+    /// A literal string which should directly be emitted
+    String(&'self str),
+    /// A back-reference to whatever the current argument is. This is used
+    /// inside of a method call to refer back to the original argument.
+    CurrentArgument,
+    /// This describes that formatting should process the next argument (as
+    /// specified inside) for emission.
+    Argument(Argument<'self>),
+}
+
+/// Representation of an argument specification.
+#[deriving(Eq)]
+pub struct Argument<'self> {
+    /// Where to find this argument
+    position: Position<'self>,
+    /// How to format the argument
+    format: FormatSpec<'self>,
+    /// If not `None`, what method to invoke on the argument
+    method: Option<~Method<'self>>
+}
+
+/// Specification for the formatting of an argument in the format string.
+#[deriving(Eq)]
+pub struct FormatSpec<'self> {
+    /// Optionally specified character to fill alignment with
+    fill: Option<char>,
+    /// Optionally specified alignment
+    align: Option<Alignment>,
+    /// Packed version of various flags provided
+    flags: uint,
+    /// The integer precision to use
+    precision: Count,
+    /// The string width requested for the resulting format
+    width: Count,
+    /// The descriptor string representing the name of the format desired for
+    /// this argument, this can be empty or any number of characters, although
+    /// it is required to be one word.
+    ty: &'self str
+}
+
+/// Enum describing where an argument for a format can be located.
+#[deriving(Eq)]
+pub enum Position<'self> {
+    ArgumentNext, ArgumentIs(uint), ArgumentNamed(&'self str)
+}
+
+/// Enum of alignments which are supoprted.
+#[deriving(Eq)]
+pub enum Alignment { AlignLeft, AlignRight }
+
+/// Various flags which can be applied to format strings, the meaning of these
+/// flags is defined by the formatters themselves.
+#[deriving(Eq)]
+pub enum Flag {
+    FlagSignPlus,
+    FlagSignMinus,
+    FlagAlternate,
+}
+
+/// A count is used for the precision and width parameters of an integer, and
+/// can reference either an argument or a literal integer.
+#[deriving(Eq)]
+pub enum Count {
+    CountIs(uint),
+    CountIsParam(uint),
+    CountIsNextParam,
+    CountImplied,
+}
+
+/// Enum describing all of the possible methods which the formatting language
+/// currently supports.
+#[deriving(Eq)]
+pub enum Method<'self> {
+    /// A plural method selects on an integer over a list of either integer or
+    /// keyword-defined clauses. The meaning of the keywords is defined by the
+    /// current locale.
+    ///
+    /// An offset is optionally present at the beginning which is used to match
+    /// against keywords, but it is not matched against the literal integers.
+    ///
+    /// The final element of this enum is the default "other" case which is
+    /// always required to be specified.
+    Plural(Option<uint>, ~[PluralArm<'self>], ~[Piece<'self>]),
+
+    /// A select method selects over a string. Each arm is a different string
+    /// which can be selected for.
+    ///
+    /// As with `Plural`, a default "other" case is required as well.
+    Select(~[SelectArm<'self>], ~[Piece<'self>]),
+}
+
+/// Structure representing one "arm" of the `plural` function.
+#[deriving(Eq)]
+pub struct PluralArm<'self> {
+    /// A selector can either be specified by a keyword or with an integer
+    /// literal.
+    selector: Either<PluralKeyword, uint>,
+    /// Array of pieces which are the format of this arm
+    result: ~[Piece<'self>],
+}
+
+/// Enum of the 5 CLDR plural keywords. There is one more, "other", but that is
+/// specially placed in the `Plural` variant of `Method`
+///
+/// http://www.icu-project.org/apiref/icu4c/classicu_1_1PluralRules.html
+#[deriving(Eq, IterBytes)]
+pub enum PluralKeyword {
+    Zero, One, Two, Few, Many
+}
+
+/// Structure representing one "arm" of the `select` function.
+#[deriving(Eq)]
+pub struct SelectArm<'self> {
+    /// String selector which guards this arm
+    selector: &'self str,
+    /// Array of pieces which are the format of this arm
+    result: ~[Piece<'self>],
+}
+
+/// The parser structure for interpreting the input format string. This is
+/// modelled as an iterator over `Piece` structures to form a stream of tokens
+/// being output.
+///
+/// This is a recursive-descent parser for the sake of simplicity, and if
+/// necessary there's probably lots of room for improvement performance-wise.
+pub struct Parser<'self> {
+    priv input: &'self str,
+    priv cur: str::CharOffsetIterator<'self>,
+}
+
+impl<'self> iterator::Iterator<Piece<'self>> for Parser<'self> {
+    fn next(&mut self) -> Option<Piece<'self>> {
+        match self.cur.clone().next() {
+            Some((_, '#')) => { self.cur.next(); Some(CurrentArgument) }
+            Some((_, '{')) => {
+                self.cur.next();
+                let ret = Some(Argument(self.argument()));
+                if !self.consume('}') {
+                    self.err(~"unterminated format string");
+                }
+                ret
+            }
+            Some((pos, '\\')) => {
+                self.cur.next();
+                self.escape(); // ensure it's a valid escape sequence
+                Some(String(self.string(pos + 1))) // skip the '\' character
+            }
+            Some((_, '}')) | None => { None }
+            Some((pos, _)) => {
+                Some(String(self.string(pos)))
+            }
+        }
+    }
+}
+
+impl<'self> Parser<'self> {
+    /// Creates a new parser for the given format string
+    pub fn new<'a>(s: &'a str) -> Parser<'a> {
+        Parser {
+            input: s,
+            cur: s.char_offset_iter(),
+        }
+    }
+
+    /// Notifies of an error. The message doesn't actually need to be of type
+    /// ~str, but I think it does when this eventually uses conditions so it
+    /// might as well start using it now.
+    fn err(&self, msg: ~str) {
+        parse_error::cond.raise(msg);
+    }
+
+    /// Optionally consumes the specified character. If the character is not at
+    /// the current position, then the current iterator isn't moved and false is
+    /// returned, otherwise the character is consumed and true is returned.
+    fn consume(&mut self, c: char) -> bool {
+        match self.cur.clone().next() {
+            Some((_, maybe)) if c == maybe => {
+                self.cur.next();
+                true
+            }
+            Some(*) | None => false,
+        }
+    }
+
+    /// Attempts to consume any amount of whitespace followed by a character
+    fn wsconsume(&mut self, c: char) -> bool {
+        self.ws(); self.consume(c)
+    }
+
+    /// Consumes all whitespace characters until the first non-whitespace
+    /// character
+    fn ws(&mut self) {
+        loop {
+            match self.cur.clone().next() {
+                Some((_, c)) if char::is_whitespace(c) => { self.cur.next(); }
+                Some(*) | None => { return }
+            }
+        }
+    }
+
+    /// Consumes an escape sequence, failing if there is not a valid character
+    /// to be escaped.
+    fn escape(&mut self) -> char {
+        match self.cur.next() {
+            Some((_, c @ '#')) | Some((_, c @ '{')) |
+            Some((_, c @ '\\')) | Some((_, c @ '}')) => { c }
+            Some((_, c)) => {
+                self.err(fmt!("invalid escape character `%c`", c));
+                c
+            }
+            None => {
+                self.err(~"expected an escape sequence, but format string was \
+                           terminated");
+                ' '
+            }
+        }
+    }
+
+    /// Parses all of a string which is to be considered a "raw literal" in a
+    /// format string. This is everything outside of the braces.
+    fn string(&mut self, start: uint) -> &'self str {
+        loop {
+            // we may not consume the character, so clone the iterator
+            match self.cur.clone().next() {
+                Some((pos, '\\')) | Some((pos, '#')) |
+                Some((pos, '}')) | Some((pos, '{')) => {
+                    return self.input.slice(start, pos);
+                }
+                Some(*) => { self.cur.next(); }
+                None => {
+                    self.cur.next();
+                    return self.input.slice(start, self.input.len());
+                }
+            }
+        }
+    }
+
+    /// Parses an Argument structure, or what's contained within braces inside
+    /// the format string
+    fn argument(&mut self) -> Argument<'self> {
+        Argument {
+            position: self.position(),
+            format: self.format(),
+            method: self.method(),
+        }
+    }
+
+    /// Parses a positional argument for a format. This could either be an
+    /// integer index of an argument, a named argument, or a blank string.
+    fn position(&mut self) -> Position<'self> {
+        match self.integer() {
+            Some(i) => { ArgumentIs(i) }
+            None => {
+                match self.cur.clone().next() {
+                    Some((_, c)) if char::is_alphabetic(c) => {
+                        ArgumentNamed(self.word())
+                    }
+                    _ => ArgumentNext
+                }
+            }
+        }
+    }
+
+    /// Parses a format specifier at the current position, returning all of the
+    /// relevant information in the FormatSpec struct.
+    fn format(&mut self) -> FormatSpec<'self> {
+        let mut spec = FormatSpec {
+            fill: None,
+            align: None,
+            flags: 0,
+            precision: CountImplied,
+            width: CountImplied,
+            ty: self.input.slice(0, 0),
+        };
+        if !self.consume(':') { return spec }
+
+        // fill character
+        match self.cur.clone().next() {
+            Some((_, c)) => {
+                match self.cur.clone().skip(1).next() {
+                    Some((_, '>')) | Some((_, '<')) => {
+                        spec.fill = Some(c);
+                        self.cur.next();
+                    }
+                    Some(*) | None => {}
+                }
+            }
+            None => {}
+        }
+        // Alignment
+        if self.consume('<') {
+            spec.align = Some(AlignLeft);
+        } else if self.consume('>') {
+            spec.align = Some(AlignRight);
+        }
+        // Sign flags
+        if self.consume('+') {
+            spec.flags |= 1 << (FlagSignPlus as uint);
+        } else if self.consume('-') {
+            spec.flags |= 1 << (FlagSignMinus as uint);
+        }
+        // Alternate marker
+        if self.consume('#') {
+            spec.flags |= 1 << (FlagAlternate as uint);
+        }
+        // Width and precision
+        spec.width = self.count();
+        if self.consume('.') {
+            if self.consume('*') {
+                spec.precision = CountIsNextParam;
+            } else {
+                spec.precision = self.count();
+            }
+        }
+        // Finally the actual format specifier
+        spec.ty = self.word();
+        return spec;
+    }
+
+    /// Parses a method to be applied to the previously specified argument and
+    /// its format. The two current supported methods are 'plural' and 'select'
+    fn method(&mut self) -> Option<~Method<'self>> {
+        if !self.wsconsume(',') {
+            return None;
+        }
+        self.ws();
+        match self.word() {
+            "select" => {
+                if !self.wsconsume(',') {
+                    self.err(~"`select` must be followed by `,`");
+                }
+                Some(self.select())
+            }
+            "plural" => {
+                if !self.wsconsume(',') {
+                    self.err(~"`plural` must be followed by `,`");
+                }
+                Some(self.plural())
+            }
+            "" => {
+                self.err(~"expected method after comma");
+                return None;
+            }
+            method => {
+                self.err(fmt!("unknown method: `%s`", method));
+                return None;
+            }
+        }
+    }
+
+    /// Parses a 'select' statement (after the initial 'select' word)
+    fn select(&mut self) -> ~Method<'self> {
+        let mut other = None;
+        let mut arms = ~[];
+        // Consume arms one at a time
+        loop {
+            self.ws();
+            let selector = self.word();
+            if selector == "" {
+                self.err(~"cannot have an empty selector");
+                break
+            }
+            if !self.wsconsume('{') {
+                self.err(~"selector must be followed by `{`");
+            }
+            let pieces = self.collect();
+            if !self.wsconsume('}') {
+                self.err(~"selector case must be terminated by `}`");
+            }
+            if selector == "other" {
+                if !other.is_none() {
+                    self.err(~"multiple `other` statements in `select");
+                }
+                other = Some(pieces);
+            } else {
+                arms.push(SelectArm { selector: selector, result: pieces });
+            }
+            self.ws();
+            match self.cur.clone().next() {
+                Some((_, '}')) => { break }
+                Some(*) | None => {}
+            }
+        }
+        // The "other" selector must be present
+        let other = match other {
+            Some(arm) => { arm }
+            None => {
+                self.err(~"`select` statement must provide an `other` case");
+                ~[]
+            }
+        };
+        ~Select(arms, other)
+    }
+
+    /// Parses a 'plural' statement (after the initial 'plural' word)
+    fn plural(&mut self) -> ~Method<'self> {
+        let mut offset = None;
+        let mut other = None;
+        let mut arms = ~[];
+
+        // First, attempt to parse the 'offset:' field. We know the set of
+        // selector words which can appear in plural arms, and the only ones
+        // which start with 'o' are "other" and "offset", hence look two
+        // characters deep to see if we can consume the word "offset"
+        self.ws();
+        let mut it = self.cur.clone();
+        match it.next() {
+            Some((_, 'o')) => {
+                match it.next() {
+                    Some((_, 'f')) => {
+                        let word = self.word();
+                        if word != "offset" {
+                            self.err(fmt!("expected `offset`, found `%s`",
+                                          word));
+                        } else {
+                            if !self.consume(':') {
+                                self.err(~"`offset` must be followed by `:`");
+                            }
+                            match self.integer() {
+                                Some(i) => { offset = Some(i); }
+                                None => {
+                                    self.err(~"offset must be an integer");
+                                }
+                            }
+                        }
+                    }
+                    Some(*) | None => {}
+                }
+            }
+            Some(*) | None => {}
+        }
+
+        // Next, generate all the arms
+        loop {
+            let mut isother = false;
+            let selector = if self.wsconsume('=') {
+                match self.integer() {
+                    Some(i) => Right(i),
+                    None => {
+                        self.err(~"plural `=` selectors must be followed by an \
+                                   integer");
+                        Right(0)
+                    }
+                }
+            } else {
+                let word = self.word();
+                match word {
+                    "other" => { isother = true; Left(Zero) }
+                    "zero"  => Left(Zero),
+                    "one"   => Left(One),
+                    "two"   => Left(Two),
+                    "few"   => Left(Few),
+                    "many"  => Left(Many),
+                    word    => {
+                        self.err(fmt!("unexpected plural selector `%s`", word));
+                        if word == "" {
+                            break
+                        } else {
+                            Left(Zero)
+                        }
+                    }
+                }
+            };
+            if !self.wsconsume('{') {
+                self.err(~"selector must be followed by `{`");
+            }
+            let pieces = self.collect();
+            if !self.wsconsume('}') {
+                self.err(~"selector case must be terminated by `}`");
+            }
+            if isother {
+                if !other.is_none() {
+                    self.err(~"multiple `other` statements in `select");
+                }
+                other = Some(pieces);
+            } else {
+                arms.push(PluralArm { selector: selector, result: pieces });
+            }
+            self.ws();
+            match self.cur.clone().next() {
+                Some((_, '}')) => { break }
+                Some(*) | None => {}
+            }
+        }
+
+        let other = match other {
+            Some(arm) => { arm }
+            None => {
+                self.err(~"`plural` statement must provide an `other` case");
+                ~[]
+            }
+        };
+        ~Plural(offset, arms, other)
+    }
+
+    /// Parses a Count parameter at the current position. This does not check
+    /// for 'CountIsNextParam' because that is only used in precision, not
+    /// width.
+    fn count(&mut self) -> Count {
+        match self.integer() {
+            Some(i) => {
+                if self.consume('$') {
+                    CountIsParam(i)
+                } else {
+                    CountIs(i)
+                }
+            }
+            None => { CountImplied }
+        }
+    }
+
+    /// Parses a word starting at the current position. A word is considered to
+    /// be an alphabetic character followed by any number of alphanumeric
+    /// characters.
+    fn word(&mut self) -> &'self str {
+        let start = match self.cur.clone().next() {
+            Some((pos, c)) if char::is_alphabetic(c) => {
+                self.cur.next();
+                pos
+            }
+            Some(*) | None => { return self.input.slice(0, 0); }
+        };
+        let mut end;
+        loop {
+            match self.cur.clone().next() {
+                Some((_, c)) if char::is_alphanumeric(c) => {
+                    self.cur.next();
+                }
+                Some((pos, _)) => { end = pos; break }
+                None => { end = self.input.len(); break }
+            }
+        }
+        self.input.slice(start, end)
+    }
+
+    /// Optionally parses an integer at the current position. This doesn't deal
+    /// with overflow at all, it's just accumulating digits.
+    fn integer(&mut self) -> Option<uint> {
+        let mut cur = 0;
+        let mut found = false;
+        loop {
+            match self.cur.clone().next() {
+                Some((_, c)) => {
+                    match char::to_digit(c, 10) {
+                        Some(i) => {
+                            cur = cur * 10 + i;
+                            found = true;
+                            self.cur.next();
+                        }
+                        None => { break }
+                    }
+                }
+                None => { break }
+            }
+        }
+        if found {
+            return Some(cur);
+        } else {
+            return None;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use prelude::*;
+    use realstd::fmt::{String};
+
+    fn same(fmt: &'static str, p: ~[Piece<'static>]) {
+        let mut parser = Parser::new(fmt);
+        assert_eq!(p, parser.collect());
+    }
+
+    fn fmtdflt() -> FormatSpec<'static> {
+        return FormatSpec {
+            fill: None,
+            align: None,
+            flags: 0,
+            precision: CountImplied,
+            width: CountImplied,
+            ty: "",
+        }
+    }
+
+    fn musterr(s: &str) {
+        Parser::new(s).next();
+    }
+
+    #[test]
+    fn simple() {
+        same("asdf", ~[String("asdf")]);
+        same("a\\{b", ~[String("a"), String("{b")]);
+        same("a\\#b", ~[String("a"), String("#b")]);
+        same("a\\}b", ~[String("a"), String("}b")]);
+        same("a\\}", ~[String("a"), String("}")]);
+        same("\\}", ~[String("}")]);
+    }
+
+    #[test] #[should_fail] fn invalid01() { musterr("{") }
+    #[test] #[should_fail] fn invalid02() { musterr("\\") }
+    #[test] #[should_fail] fn invalid03() { musterr("\\a") }
+    #[test] #[should_fail] fn invalid04() { musterr("{3a}") }
+    #[test] #[should_fail] fn invalid05() { musterr("{:|}") }
+    #[test] #[should_fail] fn invalid06() { musterr("{:>>>}") }
+
+    #[test]
+    fn format_nothing() {
+        same("{}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: fmtdflt(),
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_position() {
+        same("{3}", ~[Argument(Argument {
+            position: ArgumentIs(3),
+            format: fmtdflt(),
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_position_nothing_else() {
+        same("{3:}", ~[Argument(Argument {
+            position: ArgumentIs(3),
+            format: fmtdflt(),
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_type() {
+        same("{3:a}", ~[Argument(Argument {
+            position: ArgumentIs(3),
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: 0,
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "a",
+            },
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_align_fill() {
+        same("{3:>}", ~[Argument(Argument {
+            position: ArgumentIs(3),
+            format: FormatSpec {
+                fill: None,
+                align: Some(AlignRight),
+                flags: 0,
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "",
+            },
+            method: None,
+        })]);
+        same("{3:0<}", ~[Argument(Argument {
+            position: ArgumentIs(3),
+            format: FormatSpec {
+                fill: Some('0'),
+                align: Some(AlignLeft),
+                flags: 0,
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "",
+            },
+            method: None,
+        })]);
+        same("{3:*<abcd}", ~[Argument(Argument {
+            position: ArgumentIs(3),
+            format: FormatSpec {
+                fill: Some('*'),
+                align: Some(AlignLeft),
+                flags: 0,
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "abcd",
+            },
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_counts() {
+        same("{:10s}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: 0,
+                precision: CountImplied,
+                width: CountIs(10),
+                ty: "s",
+            },
+            method: None,
+        })]);
+        same("{:10$.10s}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: 0,
+                precision: CountIs(10),
+                width: CountIsParam(10),
+                ty: "s",
+            },
+            method: None,
+        })]);
+        same("{:.*s}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: 0,
+                precision: CountIsNextParam,
+                width: CountImplied,
+                ty: "s",
+            },
+            method: None,
+        })]);
+        same("{:.10$s}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: 0,
+                precision: CountIsParam(10),
+                width: CountImplied,
+                ty: "s",
+            },
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_flags() {
+        same("{:-}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: (1 << FlagSignMinus as uint),
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "",
+            },
+            method: None,
+        })]);
+        same("{:+#}", ~[Argument(Argument {
+            position: ArgumentNext,
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: (1 << FlagSignPlus as uint) | (1 << FlagAlternate as uint),
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "",
+            },
+            method: None,
+        })]);
+    }
+    #[test]
+    fn format_mixture() {
+        same("abcd {3:a} efg", ~[String("abcd "), Argument(Argument {
+            position: ArgumentIs(3),
+            format: FormatSpec {
+                fill: None,
+                align: None,
+                flags: 0,
+                precision: CountImplied,
+                width: CountImplied,
+                ty: "a",
+            },
+            method: None,
+        }), String(" efg")]);
+    }
+
+    #[test]
+    fn select_simple() {
+        same("{, select, other { haha } }", ~[Argument(Argument{
+            position: ArgumentNext,
+            format: fmtdflt(),
+            method: Some(~Select(~[], ~[String(" haha ")]))
+        })]);
+        same("{1, select, other { haha } }", ~[Argument(Argument{
+            position: ArgumentIs(1),
+            format: fmtdflt(),
+            method: Some(~Select(~[], ~[String(" haha ")]))
+        })]);
+        same("{1, select, other {#} }", ~[Argument(Argument{
+            position: ArgumentIs(1),
+            format: fmtdflt(),
+            method: Some(~Select(~[], ~[CurrentArgument]))
+        })]);
+        same("{1, select, other {{2, select, other {lol}}} }", ~[Argument(Argument{
+            position: ArgumentIs(1),
+            format: fmtdflt(),
+            method: Some(~Select(~[], ~[Argument(Argument{
+                position: ArgumentIs(2),
+                format: fmtdflt(),
+                method: Some(~Select(~[], ~[String("lol")]))
+            })])) // wat
+        })]);
+    }
+
+    #[test]
+    fn select_cases() {
+        same("{1, select, a{1} b{2} c{3} other{4} }", ~[Argument(Argument{
+            position: ArgumentIs(1),
+            format: fmtdflt(),
+            method: Some(~Select(~[
+                SelectArm{ selector: "a", result: ~[String("1")] },
+                SelectArm{ selector: "b", result: ~[String("2")] },
+                SelectArm{ selector: "c", result: ~[String("3")] },
+            ], ~[String("4")]))
+        })]);
+    }
+
+    #[test] #[should_fail] fn badselect01() {
+        musterr("{select, }")
+    }
+    #[test] #[should_fail] fn badselect02() {
+        musterr("{1, select}")
+    }
+    #[test] #[should_fail] fn badselect03() {
+        musterr("{1, select, }")
+    }
+    #[test] #[should_fail] fn badselect04() {
+        musterr("{1, select, a {}}")
+    }
+    #[test] #[should_fail] fn badselect05() {
+        musterr("{1, select, other }}")
+    }
+    #[test] #[should_fail] fn badselect06() {
+        musterr("{1, select, other {}")
+    }
+    #[test] #[should_fail] fn badselect07() {
+        musterr("{select, other {}")
+    }
+    #[test] #[should_fail] fn badselect08() {
+        musterr("{1 select, other {}")
+    }
+    #[test] #[should_fail] fn badselect09() {
+        musterr("{:d select, other {}")
+    }
+    #[test] #[should_fail] fn badselect10() {
+        musterr("{1:d select, other {}")
+    }
+
+    #[test]
+    fn plural_simple() {
+        same("{, plural, other { haha } }", ~[Argument(Argument{
+            position: ArgumentNext,
+            format: fmtdflt(),
+            method: Some(~Plural(None, ~[], ~[String(" haha ")]))
+        })]);
+        same("{:, plural, other { haha } }", ~[Argument(Argument{
+            position: ArgumentNext,
+            format: fmtdflt(),
+            method: Some(~Plural(None, ~[], ~[String(" haha ")]))
+        })]);
+        same("{, plural, offset:1 =2{2} =3{3} many{yes} other{haha} }",
+        ~[Argument(Argument{
+            position: ArgumentNext,
+            format: fmtdflt(),
+            method: Some(~Plural(Some(1), ~[
+                PluralArm{ selector: Right(2), result: ~[String("2")] },
+                PluralArm{ selector: Right(3), result: ~[String("3")] },
+                PluralArm{ selector: Left(Many), result: ~[String("yes")] }
+            ], ~[String("haha")]))
+        })]);
+    }
+}
diff --git a/src/libstd/fmt/rt.rs b/src/libstd/fmt/rt.rs
new file mode 100644
index 00000000000..6feb1d7a848
--- /dev/null
+++ b/src/libstd/fmt/rt.rs
@@ -0,0 +1,62 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! This is an internal module used by the ifmt! runtime. These structures are
+//! emitted to static arrays to precompile format strings ahead of time.
+//!
+//! These definitions are similar to their `ct` equivalents, but differ in that
+//! these can be statically allocated and are slightly optimized for the runtime
+
+#[allow(missing_doc)];
+#[doc(hidden)];
+
+use either::Either;
+use fmt::parse;
+use option::Option;
+
+pub enum Piece<'self> {
+    String(&'self str),
+    // FIXME(#8259): this shouldn't require the unit-value here
+    CurrentArgument(()),
+    Argument(Argument<'self>),
+}
+
+pub struct Argument<'self> {
+    position: Position,
+    format: FormatSpec,
+    method: Option<&'self Method<'self>>
+}
+
+pub struct FormatSpec {
+    fill: char,
+    alignleft: bool,
+    flags: uint,
+    precision: parse::Count,
+    width: parse::Count,
+}
+
+pub enum Position {
+    ArgumentNext, ArgumentIs(uint)
+}
+
+pub enum Method<'self> {
+    Plural(Option<uint>, &'self [PluralArm<'self>], &'self [Piece<'self>]),
+    Select(&'self [SelectArm<'self>], &'self [Piece<'self>]),
+}
+
+pub struct PluralArm<'self> {
+    selector: Either<parse::PluralKeyword, uint>,
+    result: &'self [Piece<'self>],
+}
+
+pub struct SelectArm<'self> {
+    selector: &'self str,
+    result: &'self [Piece<'self>],
+}
diff --git a/src/libstd/rt/io/mem.rs b/src/libstd/rt/io/mem.rs
index c93945a6a9a..277897e5d2e 100644
--- a/src/libstd/rt/io/mem.rs
+++ b/src/libstd/rt/io/mem.rs
@@ -26,7 +26,7 @@ pub struct MemWriter {
 }
 
 impl MemWriter {
-    pub fn new() -> MemWriter { MemWriter { buf: ~[] } }
+    pub fn new() -> MemWriter { MemWriter { buf: vec::with_capacity(128) } }
 }
 
 impl Writer for MemWriter {
diff --git a/src/libstd/std.rs b/src/libstd/std.rs
index 568709c89da..7000b56069d 100644
--- a/src/libstd/std.rs
+++ b/src/libstd/std.rs
@@ -177,6 +177,7 @@ pub mod rand;
 pub mod run;
 pub mod sys;
 pub mod cast;
+pub mod fmt;
 pub mod repr;
 pub mod cleanup;
 pub mod reflect;
@@ -216,4 +217,6 @@ mod std {
     pub use unstable;
     pub use str;
     pub use os;
+    pub use fmt;
+    pub use to_bytes;
 }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 6ed5ca3e402..99f74543e79 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -139,6 +139,8 @@ pub fn syntax_expander_table() -> SyntaxEnv {
                                 ext::tt::macro_rules::add_new_extension));
     syntax_expanders.insert(intern(&"fmt"),
                             builtin_normal_tt(ext::fmt::expand_syntax_ext));
+    syntax_expanders.insert(intern(&"ifmt"),
+                            builtin_normal_tt(ext::ifmt::expand_syntax_ext));
     syntax_expanders.insert(
         intern(&"auto_encode"),
         @SE(ItemDecorator(ext::auto_encode::expand_auto_encode)));
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index c7020b990bf..a928680e093 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -1014,7 +1014,9 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess,
         .. *afp};
     let f = make_fold(f_pre);
 
-    @f.fold_crate(c)
+    let ret = @f.fold_crate(c);
+    parse_sess.span_diagnostic.handler().abort_if_errors();
+    return ret;
 }
 
 // given a function from idents to idents, produce
diff --git a/src/libsyntax/ext/ifmt.rs b/src/libsyntax/ext/ifmt.rs
new file mode 100644
index 00000000000..5cf5fdba632
--- /dev/null
+++ b/src/libsyntax/ext/ifmt.rs
@@ -0,0 +1,720 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use ast;
+use codemap::{span, respan};
+use ext::base::*;
+use ext::base;
+use ext::build::AstBuilder;
+use rsparse = parse;
+use parse::token;
+
+use std::fmt::parse;
+use std::hashmap::{HashMap, HashSet};
+use std::vec;
+
+#[deriving(Eq)]
+enum ArgumentType {
+    Unknown,
+    Known(@str),
+    Unsigned,
+    String,
+}
+
+struct Context {
+    ecx: @ExtCtxt,
+    fmtsp: span,
+
+    // Parsed argument expressions and the types that we've found so far for
+    // them.
+    args: ~[@ast::expr],
+    arg_types: ~[Option<ArgumentType>],
+    // Parsed named expressions and the types that we've found for them so far
+    names: HashMap<@str, @ast::expr>,
+    name_types: HashMap<@str, ArgumentType>,
+
+    // Collection of the compiled `rt::Piece` structures
+    pieces: ~[@ast::expr],
+    name_positions: HashMap<@str, uint>,
+    method_statics: ~[@ast::item],
+
+    // Updated as arguments are consumed or methods are entered
+    nest_level: uint,
+    next_arg: uint,
+}
+
+impl Context {
+    /// Parses the arguments from the given list of tokens, returning None if
+    /// there's a parse error so we can continue parsing other fmt! expressions.
+    fn parse_args(&mut self, sp: span,
+                  tts: &[ast::token_tree]) -> Option<@ast::expr> {
+        let p = rsparse::new_parser_from_tts(self.ecx.parse_sess(),
+                                             self.ecx.cfg(),
+                                             tts.to_owned());
+        if *p.token == token::EOF {
+            self.ecx.span_err(sp, "ifmt! expects at least one argument");
+            return None;
+        }
+        let fmtstr = p.parse_expr();
+        let mut named = false;
+        while *p.token != token::EOF {
+            if !p.eat(&token::COMMA) {
+                self.ecx.span_err(sp, "expected token: `,`");
+                return None;
+            }
+            if named || (token::is_ident(p.token) &&
+                         p.look_ahead(1, |t| *t == token::EQ)) {
+                named = true;
+                let ident = match *p.token {
+                    token::IDENT(i, _) => {
+                        p.bump();
+                        i
+                    }
+                    _ if named => {
+                        self.ecx.span_err(*p.span,
+                                          "expected ident, positional arguments \
+                                           cannot follow named arguments");
+                        return None;
+                    }
+                    _ => {
+                        self.ecx.span_err(*p.span,
+                                          fmt!("expected ident for named \
+                                                argument, but found `%s`",
+                                               p.this_token_to_str()));
+                        return None;
+                    }
+                };
+                let name = self.ecx.str_of(ident);
+                p.expect(&token::EQ);
+                let e = p.parse_expr();
+                match self.names.find(&name) {
+                    None => {}
+                    Some(prev) => {
+                        self.ecx.span_err(e.span, fmt!("duplicate argument \
+                                                        named `%s`", name));
+                        self.ecx.parse_sess.span_diagnostic.span_note(
+                            prev.span, "previously here");
+                        loop
+                    }
+                }
+                self.names.insert(name, e);
+            } else {
+                self.args.push(p.parse_expr());
+                self.arg_types.push(None);
+            }
+        }
+        return Some(fmtstr);
+    }
+
+    /// Verifies one piece of a parse string. All errors are not emitted as
+    /// fatal so we can continue giving errors about this and possibly other
+    /// format strings.
+    fn verify_piece(&mut self, p: &parse::Piece) {
+        match *p {
+            parse::String(*) => {}
+            parse::CurrentArgument => {
+                if self.nest_level == 0 {
+                    self.ecx.span_err(self.fmtsp,
+                                      "`#` reference used with nothing to \
+                                       reference back to");
+                }
+            }
+            parse::Argument(ref arg) => {
+                // argument first (it's first in the format string)
+                let pos = match arg.position {
+                    parse::ArgumentNext => {
+                        let i = self.next_arg;
+                        if self.check_positional_ok() {
+                            self.next_arg += 1;
+                        }
+                        Left(i)
+                    }
+                    parse::ArgumentIs(i) => Left(i),
+                    parse::ArgumentNamed(s) => Right(s.to_managed()),
+                };
+                let ty = if arg.format.ty == "" {
+                    Unknown
+                } else { Known(arg.format.ty.to_managed()) };
+                self.verify_arg_type(pos, ty);
+
+                // width/precision next
+                self.verify_count(arg.format.width);
+                self.verify_count(arg.format.precision);
+
+                // and finally the method being applied
+                match arg.method {
+                    None => {}
+                    Some(ref method) => { self.verify_method(pos, *method); }
+                }
+            }
+        }
+    }
+
+    fn verify_pieces(&mut self, pieces: &[parse::Piece]) {
+        for piece in pieces.iter() {
+            self.verify_piece(piece);
+        }
+    }
+
+    fn verify_count(&mut self, c: parse::Count) {
+        match c {
+            parse::CountImplied | parse::CountIs(*) => {}
+            parse::CountIsParam(i) => {
+                self.verify_arg_type(Left(i), Unsigned);
+            }
+            parse::CountIsNextParam => {
+                if self.check_positional_ok() {
+                    self.verify_arg_type(Left(self.next_arg), Unsigned);
+                    self.next_arg += 1;
+                }
+            }
+        }
+    }
+
+    fn check_positional_ok(&mut self) -> bool {
+        if self.nest_level != 0 {
+            self.ecx.span_err(self.fmtsp, "cannot use implicit positional \
+                                           arguments nested inside methods");
+            false
+        } else {
+            true
+        }
+    }
+
+    fn verify_method(&mut self, pos: Either<uint, @str>, m: &parse::Method) {
+        self.nest_level += 1;
+        match *m {
+            parse::Plural(_, ref arms, ref default) => {
+                let mut seen_cases = HashSet::new();
+                self.verify_arg_type(pos, Unsigned);
+                for arm in arms.iter() {
+                    if !seen_cases.insert(arm.selector) {
+                        match arm.selector {
+                            Left(name) => {
+                                self.ecx.span_err(self.fmtsp,
+                                                  fmt!("duplicate selector \
+                                                       `%?`", name));
+                            }
+                            Right(idx) => {
+                                self.ecx.span_err(self.fmtsp,
+                                                  fmt!("duplicate selector \
+                                                       `=%u`", idx));
+                            }
+                        }
+                    }
+                    self.verify_pieces(arm.result);
+                }
+                self.verify_pieces(*default);
+            }
+            parse::Select(ref arms, ref default) => {
+                self.verify_arg_type(pos, String);
+                let mut seen_cases = HashSet::new();
+                for arm in arms.iter() {
+                    if !seen_cases.insert(arm.selector) {
+                        self.ecx.span_err(self.fmtsp,
+                                          fmt!("duplicate selector `%s`",
+                                               arm.selector));
+                    } else if arm.selector == "" {
+                        self.ecx.span_err(self.fmtsp,
+                                          "empty selector in `select`");
+                    }
+                    self.verify_pieces(arm.result);
+                }
+                self.verify_pieces(*default);
+            }
+        }
+        self.nest_level -= 1;
+    }
+
+    fn verify_arg_type(&mut self, arg: Either<uint, @str>, ty: ArgumentType) {
+        match arg {
+            Left(arg) => {
+                if arg < 0 || self.args.len() <= arg {
+                    let msg = fmt!("invalid reference to argument `%u` (there \
+                                    are %u arguments)", arg, self.args.len());
+                    self.ecx.span_err(self.fmtsp, msg);
+                    return;
+                }
+                self.verify_same(self.args[arg].span, ty, self.arg_types[arg]);
+                if ty != Unknown || self.arg_types[arg].is_none() {
+                    self.arg_types[arg] = Some(ty);
+                }
+            }
+
+            Right(name) => {
+                let span = match self.names.find(&name) {
+                    Some(e) => e.span,
+                    None => {
+                        let msg = fmt!("There is no argument named `%s`", name);
+                        self.ecx.span_err(self.fmtsp, msg);
+                        return;
+                    }
+                };
+                self.verify_same(span, ty,
+                                 self.name_types.find(&name).map(|&x| *x));
+                if ty != Unknown || !self.name_types.contains_key(&name) {
+                    self.name_types.insert(name, ty);
+                }
+                // Assign this named argument a slot in the arguments array if
+                // it hasn't already been assigned a slot.
+                if !self.name_positions.contains_key(&name) {
+                    let slot = self.name_positions.len();
+                    self.name_positions.insert(name, slot);
+                }
+            }
+        }
+    }
+
+    /// When we're keeping track of the types that are declared for certain
+    /// arguments, we assume that `None` means we haven't seen this argument
+    /// yet, `Some(None)` means that we've seen the argument, but no format was
+    /// specified, and `Some(Some(x))` means that the argument was declared to
+    /// have type `x`.
+    ///
+    /// Obviously `Some(Some(x)) != Some(Some(y))`, but we consider it true
+    /// that: `Some(None) == Some(Some(x))`
+    fn verify_same(&self, sp: span, ty: ArgumentType,
+                   before: Option<ArgumentType>) {
+        if ty == Unknown { return }
+        let cur = match before {
+            Some(Unknown) | None => return,
+            Some(t) => t,
+        };
+        if ty == cur { return }
+        match (cur, ty) {
+            (Known(cur), Known(ty)) => {
+                self.ecx.span_err(sp,
+                                  fmt!("argument redeclared with type `%s` when \
+                                        it was previously `%s`", ty, cur));
+            }
+            (Known(cur), _) => {
+                self.ecx.span_err(sp,
+                                  fmt!("argument used to format with `%s` was \
+                                        attempted to not be used for formatting",
+                                        cur));
+            }
+            (_, Known(ty)) => {
+                self.ecx.span_err(sp,
+                                  fmt!("argument previously used as a format \
+                                        argument attempted to be used as `%s`",
+                                        ty));
+            }
+            (_, _) => {
+                self.ecx.span_err(sp, "argument declared with multiple formats");
+            }
+        }
+    }
+
+    /// Translate a `parse::Piece` to a static `rt::Piece`
+    fn trans_piece(&mut self, piece: &parse::Piece) -> @ast::expr {
+        let sp = self.fmtsp;
+        let rtpath = |s: &str| {
+            ~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
+              self.ecx.ident_of("rt"), self.ecx.ident_of(s)]
+        };
+        let ctpath = |s: &str| {
+            ~[self.ecx.ident_of("std"), self.ecx.ident_of("fmt"),
+              self.ecx.ident_of("parse"), self.ecx.ident_of(s)]
+        };
+        let none = || {
+            let p = self.ecx.path(sp, ~[self.ecx.ident_of("None")]);
+            self.ecx.expr_path(p)
+        };
+        let some = |e: @ast::expr| {
+            self.ecx.expr_call_ident(sp, self.ecx.ident_of("Some"), ~[e])
+        };
+        let trans_count = |c: parse::Count| {
+            match c {
+                parse::CountIs(i) => {
+                    self.ecx.expr_call_global(sp, ctpath("CountIs"),
+                                              ~[self.ecx.expr_uint(sp, i)])
+                }
+                parse::CountIsParam(i) => {
+                    self.ecx.expr_call_global(sp, ctpath("CountIsParam"),
+                                              ~[self.ecx.expr_uint(sp, i)])
+                }
+                parse::CountImplied => {
+                    let path = self.ecx.path_global(sp, ctpath("CountImplied"));
+                    self.ecx.expr_path(path)
+                }
+                parse::CountIsNextParam => {
+                    let path = self.ecx.path_global(sp, ctpath("CountIsNextParam"));
+                    self.ecx.expr_path(path)
+                }
+            }
+        };
+        let trans_method = |method: &parse::Method| {
+            let method = match *method {
+                parse::Select(ref arms, ref default) => {
+                    let arms = arms.iter().transform(|arm| {
+                        let p = self.ecx.path_global(sp, rtpath("SelectArm"));
+                        let result = arm.result.iter().transform(|p| {
+                            self.trans_piece(p)
+                        }).collect();
+                        let s = arm.selector.to_managed();
+                        let selector = self.ecx.expr_str(sp, s);
+                        self.ecx.expr_struct(sp, p, ~[
+                            self.ecx.field_imm(sp,
+                                               self.ecx.ident_of("selector"),
+                                               selector),
+                            self.ecx.field_imm(sp, self.ecx.ident_of("result"),
+                                               self.ecx.expr_vec_slice(sp, result)),
+                        ])
+                    }).collect();
+                    let default = default.iter().transform(|p| {
+                        self.trans_piece(p)
+                    }).collect();
+                    self.ecx.expr_call_global(sp, rtpath("Select"), ~[
+                        self.ecx.expr_vec_slice(sp, arms),
+                        self.ecx.expr_vec_slice(sp, default),
+                    ])
+                }
+                parse::Plural(offset, ref arms, ref default) => {
+                    let offset = match offset {
+                        Some(i) => { some(self.ecx.expr_uint(sp, i)) }
+                        None => { none() }
+                    };
+                    let arms = arms.iter().transform(|arm| {
+                        let p = self.ecx.path_global(sp, rtpath("PluralArm"));
+                        let result = arm.result.iter().transform(|p| {
+                            self.trans_piece(p)
+                        }).collect();
+                        let (lr, selarg) = match arm.selector {
+                            Left(t) => {
+                                let p = ctpath(fmt!("%?", t));
+                                let p = self.ecx.path_global(sp, p);
+                                (self.ecx.ident_of("Left"),
+                                 self.ecx.expr_path(p))
+                            }
+                            Right(i) => {
+                                (self.ecx.ident_of("Right"),
+                                 self.ecx.expr_uint(sp, i))
+                            }
+                        };
+                        let selector = self.ecx.expr_call_ident(sp,
+                                lr, ~[selarg]);
+                        self.ecx.expr_struct(sp, p, ~[
+                            self.ecx.field_imm(sp,
+                                               self.ecx.ident_of("selector"),
+                                               selector),
+                            self.ecx.field_imm(sp, self.ecx.ident_of("result"),
+                                               self.ecx.expr_vec_slice(sp, result)),
+                        ])
+                    }).collect();
+                    let default = default.iter().transform(|p| {
+                        self.trans_piece(p)
+                    }).collect();
+                    self.ecx.expr_call_global(sp, rtpath("Plural"), ~[
+                        offset,
+                        self.ecx.expr_vec_slice(sp, arms),
+                        self.ecx.expr_vec_slice(sp, default),
+                    ])
+                }
+            };
+            let life = self.ecx.lifetime(sp, self.ecx.ident_of("static"));
+            let ty = self.ecx.ty_path(self.ecx.path_all(
+                sp,
+                true,
+                rtpath("Method"),
+                Some(life),
+                ~[]
+            ), None);
+            let st = ast::item_static(ty, ast::m_imm, method);
+            let static_name = self.ecx.ident_of(fmt!("__static_method_%u",
+                                                     self.method_statics.len()));
+            let item = self.ecx.item(sp, static_name, ~[], st);
+            self.method_statics.push(item);
+            self.ecx.expr_ident(sp, static_name)
+        };
+
+        match *piece {
+            parse::String(s) => {
+                self.ecx.expr_call_global(sp, rtpath("String"),
+                                          ~[self.ecx.expr_str(sp, s.to_managed())])
+            }
+            parse::CurrentArgument => {
+                let nil = self.ecx.expr_lit(sp, ast::lit_nil);
+                self.ecx.expr_call_global(sp, rtpath("CurrentArgument"), ~[nil])
+            }
+            parse::Argument(ref arg) => {
+                // Translate the position
+                let pos = match arg.position {
+                    // These two have a direct mapping
+                    parse::ArgumentNext => {
+                        let path = self.ecx.path_global(sp,
+                                                        rtpath("ArgumentNext"));
+                        self.ecx.expr_path(path)
+                    }
+                    parse::ArgumentIs(i) => {
+                        self.ecx.expr_call_global(sp, rtpath("ArgumentIs"),
+                                                  ~[self.ecx.expr_uint(sp, i)])
+                    }
+                    // Named arguments are converted to positional arguments at
+                    // the end of the list of arguments
+                    parse::ArgumentNamed(n) => {
+                        let n = n.to_managed();
+                        let i = match self.name_positions.find_copy(&n) {
+                            Some(i) => i,
+                            None => 0, // error already emitted elsewhere
+                        };
+                        let i = i + self.args.len();
+                        self.ecx.expr_call_global(sp, rtpath("ArgumentIs"),
+                                                  ~[self.ecx.expr_uint(sp, i)])
+                    }
+                };
+
+                // Translate the format
+                let fill = match arg.format.fill { Some(c) => c, None => ' ' };
+                let fill = self.ecx.expr_lit(sp, ast::lit_int(fill as i64,
+                                                              ast::ty_char));
+                let align = match arg.format.align {
+                    None | Some(parse::AlignLeft) => {
+                        self.ecx.expr_bool(sp, true)
+                    }
+                    Some(parse::AlignRight) => {
+                        self.ecx.expr_bool(sp, false)
+                    }
+                };
+                let flags = self.ecx.expr_uint(sp, arg.format.flags);
+                let prec = trans_count(arg.format.precision);
+                let width = trans_count(arg.format.width);
+                let path = self.ecx.path_global(sp, rtpath("FormatSpec"));
+                let fmt = self.ecx.expr_struct(sp, path, ~[
+                    self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
+                    self.ecx.field_imm(sp, self.ecx.ident_of("alignleft"), align),
+                    self.ecx.field_imm(sp, self.ecx.ident_of("flags"), flags),
+                    self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
+                    self.ecx.field_imm(sp, self.ecx.ident_of("width"), width),
+                ]);
+
+                // Translate the method (if any)
+                let method = match arg.method {
+                    None => { none() }
+                    Some(ref m) => {
+                        let m = trans_method(*m);
+                        some(self.ecx.expr_addr_of(sp, m))
+                    }
+                };
+                let path = self.ecx.path_global(sp, rtpath("Argument"));
+                let s = self.ecx.expr_struct(sp, path, ~[
+                    self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
+                    self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt),
+                    self.ecx.field_imm(sp, self.ecx.ident_of("method"), method),
+                ]);
+                self.ecx.expr_call_global(sp, rtpath("Argument"), ~[s])
+            }
+        }
+    }
+
+    /// Actually builds the expression which the ifmt! block will be expanded
+    /// to
+    fn to_expr(&self) -> @ast::expr {
+        let mut lets = ~[];
+        let mut locals = ~[];
+        let mut names = vec::from_fn(self.name_positions.len(), |_| None);
+
+        // First, declare all of our methods that are statics
+        for &method in self.method_statics.iter() {
+            let decl = respan(self.fmtsp, ast::decl_item(method));
+            lets.push(@respan(self.fmtsp,
+                              ast::stmt_decl(@decl, self.ecx.next_id())));
+        }
+
+        // Next, build up the static array which will become our precompiled
+        // format "string"
+        let fmt = self.ecx.expr_vec(self.fmtsp, self.pieces.clone());
+        let ty = ast::ty_fixed_length_vec(
+            self.ecx.ty_mt(
+                self.ecx.ty_path(self.ecx.path_all(
+                    self.fmtsp,
+                    true, ~[
+                        self.ecx.ident_of("std"),
+                        self.ecx.ident_of("fmt"),
+                        self.ecx.ident_of("rt"),
+                        self.ecx.ident_of("Piece"),
+                    ],
+                    Some(self.ecx.lifetime(self.fmtsp, self.ecx.ident_of("static"))),
+                    ~[]
+                ), None),
+                ast::m_imm
+            ),
+            self.ecx.expr_uint(self.fmtsp, self.pieces.len())
+        );
+        let ty = self.ecx.ty(self.fmtsp, ty);
+        let st = ast::item_static(ty, ast::m_imm, fmt);
+        let static_name = self.ecx.ident_of("__static_fmtstr");
+        let item = self.ecx.item(self.fmtsp, static_name, ~[], st);
+        let decl = respan(self.fmtsp, ast::decl_item(item));
+        lets.push(@respan(self.fmtsp, ast::stmt_decl(@decl, self.ecx.next_id())));
+
+        // Right now there is a bug such that for the expression:
+        //      foo(bar(&1))
+        // the lifetime of `1` doesn't outlast the call to `bar`, so it's not
+        // vald for the call to `foo`. To work around this all arguments to the
+        // fmt! string are shoved into locals.
+        for (i, &e) in self.args.iter().enumerate() {
+            if self.arg_types[i].is_none() { loop } // error already generated
+
+            let name = self.ecx.ident_of(fmt!("__arg%u", i));
+            lets.push(self.ecx.stmt_let(e.span, false, name, e));
+            locals.push(self.format_arg(e.span, Left(i), name));
+        }
+        for (&name, &e) in self.names.iter() {
+            if !self.name_types.contains_key(&name) { loop }
+
+            let lname = self.ecx.ident_of(fmt!("__arg%s", name));
+            lets.push(self.ecx.stmt_let(e.span, false, lname, e));
+            names[*self.name_positions.get(&name)] =
+                Some(self.format_arg(e.span, Right(name), lname));
+        }
+
+        let args = names.consume_iter().transform(|a| a.unwrap());
+        let mut args = locals.consume_iter().chain_(args);
+
+        // Next, build up the actual call to the sprintf function.
+        let result = self.ecx.expr_call_global(self.fmtsp, ~[
+                self.ecx.ident_of("std"),
+                self.ecx.ident_of("fmt"),
+                self.ecx.ident_of("sprintf"),
+            ], ~[
+                self.ecx.expr_ident(self.fmtsp, static_name),
+                self.ecx.expr_vec(self.fmtsp, args.collect()),
+            ]);
+
+        // sprintf is unsafe, but we just went through a lot of work to
+        // validate that our call is save, so inject the unsafe block for the
+        // user.
+        let result = self.ecx.expr_block(ast::Block {
+           view_items: ~[],
+           stmts: ~[],
+           expr: Some(result),
+           id: self.ecx.next_id(),
+           rules: ast::UnsafeBlock,
+           span: self.fmtsp,
+        });
+
+        self.ecx.expr_block(self.ecx.block(self.fmtsp, lets, Some(result)))
+    }
+
+    fn format_arg(&self, sp: span, arg: Either<uint, @str>,
+                  ident: ast::ident) -> @ast::expr {
+        let mut ty = match arg {
+            Left(i) => self.arg_types[i].unwrap(),
+            Right(s) => *self.name_types.get(&s)
+        };
+        // Default types to '?' if nothing else is specified.
+        if ty == Unknown {
+            ty = Known(@"?");
+        }
+        let argptr = self.ecx.expr_addr_of(sp, self.ecx.expr_ident(sp, ident));
+        match ty {
+            Known(tyname) => {
+                let fmt_trait = match tyname.as_slice() {
+                    "?" => "Poly",
+                    "d" | "i" => "Signed",
+                    "u" => "Unsigned",
+                    "b" => "Bool",
+                    "c" => "Char",
+                    "o" => "Octal",
+                    "x" => "LowerHex",
+                    "X" => "UpperHex",
+                    "s" => "String",
+                    "p" => "Pointer",
+                    _ => {
+                        self.ecx.span_err(sp, fmt!("unknown format trait \
+                                                    `%s`", tyname));
+                        "Dummy"
+                    }
+                };
+                let format_fn = self.ecx.path_global(sp, ~[
+                        self.ecx.ident_of("std"),
+                        self.ecx.ident_of("fmt"),
+                        self.ecx.ident_of(fmt_trait),
+                        self.ecx.ident_of("fmt"),
+                    ]);
+                self.ecx.expr_call_global(sp, ~[
+                        self.ecx.ident_of("std"),
+                        self.ecx.ident_of("fmt"),
+                        self.ecx.ident_of("argument"),
+                    ], ~[self.ecx.expr_path(format_fn), argptr])
+            }
+            String => {
+                self.ecx.expr_call_global(sp, ~[
+                        self.ecx.ident_of("std"),
+                        self.ecx.ident_of("fmt"),
+                        self.ecx.ident_of("argumentstr"),
+                    ], ~[argptr])
+            }
+            Unsigned => {
+                self.ecx.expr_call_global(sp, ~[
+                        self.ecx.ident_of("std"),
+                        self.ecx.ident_of("fmt"),
+                        self.ecx.ident_of("argumentuint"),
+                    ], ~[argptr])
+            }
+            Unknown => { fail!() }
+        }
+    }
+}
+
+pub fn expand_syntax_ext(ecx: @ExtCtxt, sp: span,
+                         tts: &[ast::token_tree]) -> base::MacResult {
+    let mut cx = Context {
+        ecx: ecx,
+        args: ~[],
+        arg_types: ~[],
+        names: HashMap::new(),
+        name_positions: HashMap::new(),
+        name_types: HashMap::new(),
+        nest_level: 0,
+        next_arg: 0,
+        pieces: ~[],
+        method_statics: ~[],
+        fmtsp: sp,
+    };
+    let efmt = match cx.parse_args(sp, tts) {
+        Some(e) => e,
+        None => { return MRExpr(ecx.expr_uint(sp, 2)); }
+    };
+    cx.fmtsp = efmt.span;
+    let fmt = expr_to_str(ecx, efmt,
+                          ~"first argument to ifmt! must be a string literal.");
+
+    let mut err = false;
+    do parse::parse_error::cond.trap(|m| {
+        if !err {
+            err = true;
+            ecx.span_err(efmt.span, m);
+        }
+    }).inside {
+        for piece in parse::Parser::new(fmt) {
+            if !err {
+                cx.verify_piece(&piece);
+                let piece = cx.trans_piece(&piece);
+                cx.pieces.push(piece);
+            }
+        }
+    }
+    if err { return MRExpr(efmt) }
+
+    // Make sure that all arguments were used and all arguments have types.
+    for (i, ty) in cx.arg_types.iter().enumerate() {
+        if ty.is_none() {
+            ecx.span_err(cx.args[i].span, "argument never used");
+        }
+    }
+    for (name, e) in cx.names.iter() {
+        if !cx.name_types.contains_key(name) {
+            ecx.span_err(e.span, "named argument never used");
+        }
+    }
+
+    MRExpr(cx.to_expr())
+}
diff --git a/src/libsyntax/syntax.rs b/src/libsyntax/syntax.rs
index e0f5aa848a2..a5feb0483d8 100644
--- a/src/libsyntax/syntax.rs
+++ b/src/libsyntax/syntax.rs
@@ -73,6 +73,7 @@ pub mod ext {
 
     pub mod cfg;
     pub mod fmt;
+    pub mod ifmt;
     pub mod env;
     pub mod bytes;
     pub mod concat_idents;
diff --git a/src/test/compile-fail/ifmt-bad-arg.rs b/src/test/compile-fail/ifmt-bad-arg.rs
new file mode 100644
index 00000000000..875ad0d2b62
--- /dev/null
+++ b/src/test/compile-fail/ifmt-bad-arg.rs
@@ -0,0 +1,74 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    // bad arguments to the ifmt! call
+
+    ifmt!();                //~ ERROR: expects at least one
+    ifmt!("{}");            //~ ERROR: invalid reference to argument
+
+    ifmt!("{1}", 1);        //~ ERROR: invalid reference to argument `1`
+                            //~^ ERROR: argument never used
+    ifmt!("{foo}");         //~ ERROR: no argument named `foo`
+
+    ifmt!("{}", 1, 2);               //~ ERROR: argument never used
+    ifmt!("{1}", 1, 2);              //~ ERROR: argument never used
+    ifmt!("{}", 1, foo=2);           //~ ERROR: named argument never used
+    ifmt!("{foo}", 1, foo=2);        //~ ERROR: argument never used
+    ifmt!("", foo=2);                //~ ERROR: named argument never used
+
+    ifmt!("{0:d} {0:s}", 1);         //~ ERROR: redeclared with type `s`
+    ifmt!("{foo:d} {foo:s}", foo=1); //~ ERROR: redeclared with type `s`
+
+    ifmt!("{foo}", foo=1, foo=2);    //~ ERROR: duplicate argument
+    ifmt!("#");                      //~ ERROR: `#` reference used
+    ifmt!("", foo=1, 2);             //~ ERROR: positional arguments cannot follow
+    ifmt!("" 1);                     //~ ERROR: expected token: `,`
+    ifmt!("", 1 1);                  //~ ERROR: expected token: `,`
+
+    ifmt!("{0, select, a{} a{} other{}}", "a");    //~ ERROR: duplicate selector
+    ifmt!("{0, plural, =1{} =1{} other{}}", 1u);   //~ ERROR: duplicate selector
+    ifmt!("{0, plural, one{} one{} other{}}", 1u); //~ ERROR: duplicate selector
+
+    // bad syntax of the format string
+
+    ifmt!("{"); //~ ERROR: unterminated format string
+    ifmt!("\\ "); //~ ERROR: invalid escape
+    ifmt!("\\"); //~ ERROR: expected an escape
+
+    ifmt!("{0, }", 1); //~ ERROR: expected method
+    ifmt!("{0, foo}", 1); //~ ERROR: unknown method
+    ifmt!("{0, select}", "a"); //~ ERROR: must be followed by
+    ifmt!("{0, plural}", 1); //~ ERROR: must be followed by
+
+    ifmt!("{0, select, a{{}", 1); //~ ERROR: must be terminated
+    ifmt!("{0, select, {} other{}}", "a"); //~ ERROR: empty selector
+    ifmt!("{0, select, other{} other{}}", "a"); //~ ERROR: multiple `other`
+    ifmt!("{0, plural, offset: other{}}", "a"); //~ ERROR: must be an integer
+    ifmt!("{0, plural, offset 1 other{}}", "a"); //~ ERROR: be followed by `:`
+    ifmt!("{0, plural, =a{} other{}}", "a"); //~ ERROR: followed by an integer
+    ifmt!("{0, plural, a{} other{}}", "a"); //~ ERROR: unexpected plural
+    ifmt!("{0, select, a{}}", "a"); //~ ERROR: must provide an `other`
+    ifmt!("{0, plural, =1{}}", "a"); //~ ERROR: must provide an `other`
+
+    ifmt!("{0, plural, other{{0:s}}}", "a"); //~ ERROR: previously used as
+    ifmt!("{:s} {0, plural, other{}}", "a"); //~ ERROR: argument used to
+    ifmt!("{0, select, other{}} \
+           {0, plural, other{}}", "a");
+    //~^ ERROR: declared with multiple formats
+
+    // It should be illegal to use implicit placement arguments nested inside of
+    // format strings because otherwise the "internal pointer of which argument
+    // is next" would be invalidated if different cases had different numbers of
+    // arguments.
+    ifmt!("{0, select, other{{}}}", "a"); //~ ERROR: cannot use implicit
+    ifmt!("{0, plural, other{{}}}", 1); //~ ERROR: cannot use implicit
+    ifmt!("{0, plural, other{{1:.*d}}}", 1, 2); //~ ERROR: cannot use implicit
+}
diff --git a/src/test/compile-fail/ifmt-bad-plural.rs b/src/test/compile-fail/ifmt-bad-plural.rs
new file mode 100644
index 00000000000..76a697b174f
--- /dev/null
+++ b/src/test/compile-fail/ifmt-bad-plural.rs
@@ -0,0 +1,14 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    ifmt!("{0, plural, other{}}", "a");
+    //~^ ERROR: expected uint but found
+}
diff --git a/src/test/compile-fail/ifmt-bad-select.rs b/src/test/compile-fail/ifmt-bad-select.rs
new file mode 100644
index 00000000000..abe3b6ed65a
--- /dev/null
+++ b/src/test/compile-fail/ifmt-bad-select.rs
@@ -0,0 +1,14 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    ifmt!("{0, select, other{}}", 2);
+    //~^ ERROR: expected &str but found integral
+}
diff --git a/src/test/compile-fail/ifmt-unimpl.rs b/src/test/compile-fail/ifmt-unimpl.rs
new file mode 100644
index 00000000000..427f5ea562c
--- /dev/null
+++ b/src/test/compile-fail/ifmt-unimpl.rs
@@ -0,0 +1,14 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    ifmt!("{:d}", "3");
+    //~^ ERROR: failed to find an implementation of trait std::fmt::Signed
+}
diff --git a/src/test/compile-fail/ifmt-unknown-trait.rs b/src/test/compile-fail/ifmt-unknown-trait.rs
new file mode 100644
index 00000000000..85556f9501a
--- /dev/null
+++ b/src/test/compile-fail/ifmt-unknown-trait.rs
@@ -0,0 +1,14 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    ifmt!("{:notimplemented}", "3");
+    //~^ ERROR: unknown format trait `notimplemented`
+}
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
new file mode 100644
index 00000000000..562642453fd
--- /dev/null
+++ b/src/test/run-pass/ifmt.rs
@@ -0,0 +1,71 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+
+struct A;
+struct B;
+
+#[fmt="foo"]
+impl fmt::Signed for A {
+    fn fmt(_: &A, f: &mut fmt::Formatter) { f.buf.write("aloha".as_bytes()); }
+}
+impl fmt::Signed for B {
+    fn fmt(_: &B, f: &mut fmt::Formatter) { f.buf.write("adios".as_bytes()); }
+}
+
+pub fn main() {
+    fn t(a: ~str, b: &str) { assert_eq!(a, b.to_owned()); }
+
+    // Make sure there's a poly formatter that takes anything
+    t(ifmt!("{}", 1), "1");
+    t(ifmt!("{}", A), "{}");
+    t(ifmt!("{}", ()), "()");
+    t(ifmt!("{}", @(~1, "foo")), "@(~1, \"foo\")");
+
+    // Various edge cases without formats
+    t(ifmt!(""), "");
+    t(ifmt!("hello"), "hello");
+    t(ifmt!("hello \\{"), "hello {");
+
+    // At least exercise all the formats
+    t(ifmt!("{:b}", true), "true");
+    t(ifmt!("{:c}", '☃'), "☃");
+    t(ifmt!("{:d}", 10), "10");
+    t(ifmt!("{:i}", 10), "10");
+    t(ifmt!("{:u}", 10u), "10");
+    t(ifmt!("{:o}", 10u), "12");
+    t(ifmt!("{:x}", 10u), "a");
+    t(ifmt!("{:X}", 10u), "A");
+    t(ifmt!("{:s}", "foo"), "foo");
+    t(ifmt!("{:p}", 0x1234 as *int), "0x1234");
+    t(ifmt!("{:p}", 0x1234 as *mut int), "0x1234");
+    t(ifmt!("{:d}", A), "aloha");
+    t(ifmt!("{:d}", B), "adios");
+    t(ifmt!("foo {:s} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
+    t(ifmt!("{1} {0}", 0, 1), "1 0");
+    t(ifmt!("{foo} {bar}", foo=0, bar=1), "0 1");
+    t(ifmt!("{foo} {1} {bar} {0}", 0, 1, foo=2, bar=3), "2 1 3 0");
+    t(ifmt!("{} {0:s}", "a"), "a a");
+    t(ifmt!("{} {0}", "a"), "\"a\" \"a\"");
+
+    // Methods should probably work
+    t(ifmt!("{0, plural, =1{a#} =2{b#} zero{c#} other{d#}}", 0u), "c0");
+    t(ifmt!("{0, plural, =1{a#} =2{b#} zero{c#} other{d#}}", 1u), "a1");
+    t(ifmt!("{0, plural, =1{a#} =2{b#} zero{c#} other{d#}}", 2u), "b2");
+    t(ifmt!("{0, plural, =1{a#} =2{b#} zero{c#} other{d#}}", 3u), "d3");
+    t(ifmt!("{0, select, a{a#} b{b#} c{c#} other{d#}}", "a"), "aa");
+    t(ifmt!("{0, select, a{a#} b{b#} c{c#} other{d#}}", "b"), "bb");
+    t(ifmt!("{0, select, a{a#} b{b#} c{c#} other{d#}}", "c"), "cc");
+    t(ifmt!("{0, select, a{a#} b{b#} c{c#} other{d#}}", "d"), "dd");
+    t(ifmt!("{1, select, a{#{0:s}} other{#{1}}}", "b", "a"), "ab");
+    t(ifmt!("{1, select, a{#{0}} other{#{1}}}", "c", "b"), "bb");
+}
+
-- 
cgit 1.4.1-3-g733a5


From 40bdbf0f5d1e997891918a2bf8bec5fc61432f05 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Wed, 7 Aug 2013 16:58:56 +0200
Subject: std: Fix for-range loops that can use iterators

Fix inappropriate for-range loops to use for-iterator constructs (or
other appropriate solution) instead.
---
 src/libextra/arc.rs         | 14 ++++----------
 src/libextra/bitv.rs        | 17 +++++++++--------
 src/libextra/smallintmap.rs | 14 ++++++--------
 src/libextra/sort.rs        | 10 ++--------
 src/libstd/at_vec.rs        |  6 +++---
 src/libstd/hashmap.rs       |  6 +++---
 src/libstd/trie.rs          |  4 ++--
 src/libstd/vec.rs           |  4 ++--
 8 files changed, 31 insertions(+), 44 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
index cb4468f48ec..ad950f198ce 100644
--- a/src/libextra/arc.rs
+++ b/src/libextra/arc.rs
@@ -846,22 +846,16 @@ mod tests {
                 }
                 assert_eq!(*state, 42);
                 *state = 31337;
-                // FIXME: #7372: hits type inference bug with iterators
                 // send to other readers
-                for i in range(0u, reader_convos.len()) {
-                    match reader_convos[i] {
-                        (ref rc, _) => rc.send(()),
-                    }
+                for &(ref rc, _) in reader_convos.iter() {
+                    rc.send(())
                 }
             }
             let read_mode = arc.downgrade(write_mode);
             do (&read_mode).read |state| {
-                // FIXME: #7372: hits type inference bug with iterators
                 // complete handshake with other readers
-                for i in range(0u, reader_convos.len()) {
-                    match reader_convos[i] {
-                        (_, ref rp) => rp.recv(),
-                    }
+                for &(_, ref rp) in reader_convos.iter() {
+                    rp.recv()
                 }
                 wc1.send(()); // tell writer to try again
                 assert_eq!(*state, 31337);
diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs
index 6dedd9ee4dd..20a3add3e7b 100644
--- a/src/libextra/bitv.rs
+++ b/src/libextra/bitv.rs
@@ -145,14 +145,16 @@ impl BigBitv {
         let len = b.storage.len();
         assert_eq!(self.storage.len(), len);
         let mut changed = false;
-        for i in range(0, len) {
+        for (i, (a, b)) in self.storage.mut_iter()
+                               .zip(b.storage.iter())
+                               .enumerate() {
             let mask = big_mask(nbits, i);
-            let w0 = self.storage[i] & mask;
-            let w1 = b.storage[i] & mask;
+            let w0 = *a & mask;
+            let w1 = *b & mask;
             let w = op(w0, w1) & mask;
             if w0 != w {
                 changed = true;
-                self.storage[i] = w;
+                *a = w;
             }
         }
         changed
@@ -160,7 +162,7 @@ impl BigBitv {
 
     #[inline]
     pub fn each_storage(&mut self, op: &fn(v: &mut uint) -> bool) -> bool {
-        range(0u, self.storage.len()).advance(|i| op(&mut self.storage[i]))
+        self.storage.mut_iter().advance(|elt| op(elt))
     }
 
     #[inline]
@@ -205,10 +207,9 @@ impl BigBitv {
 
     #[inline]
     pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
-        let len = b.storage.len();
-        for i in range(0, len) {
+        for (i, elt) in b.storage.iter().enumerate() {
             let mask = big_mask(nbits, i);
-            if mask & self.storage[i] != mask & b.storage[i] {
+            if mask & self.storage[i] != mask & *elt {
                 return false;
             }
         }
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index 8103ed7a478..a601270e8ec 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -28,14 +28,12 @@ pub struct SmallIntMap<T> {
 impl<V> Container for SmallIntMap<V> {
     /// Return the number of elements in the map
     fn len(&self) -> uint {
-        let mut sz = 0;
-        for i in range(0u, self.v.len()) {
-            match self.v[i] {
-                Some(_) => sz += 1,
-                None => {}
-            }
-        }
-        sz
+        self.v.iter().count(|elt| elt.is_some())
+    }
+
+    /// Return true if there are no elements in the map
+    fn is_empty(&self) -> bool {
+        self.v.iter().all(|elt| elt.is_none())
     }
 }
 
diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs
index 8090dd26ef2..daafdbc3718 100644
--- a/src/libextra/sort.rs
+++ b/src/libextra/sort.rs
@@ -469,10 +469,7 @@ impl<T:Clone + Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert!(len1 != 0 && len2 != 0 && base1+len1 == base2);
 
-        let mut tmp = ~[];
-        for i in range(base1, base1+len1) {
-            tmp.push(array[i].clone());
-        }
+        let mut tmp = array.slice(base1, base1 + len1).to_owned();
 
         let mut c1 = 0;
         let mut c2 = base2;
@@ -579,10 +576,7 @@ impl<T:Clone + Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
 
-        let mut tmp = ~[];
-        for i in range(base2, base2+len2) {
-            tmp.push(array[i].clone());
-        }
+        let mut tmp = array.slice(base2, base2 + len2).to_owned();
 
         let mut c1 = base1 + len1 - 1;
         let mut c2 = len2 - 1;
diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index a84f3137bbd..f2470bed732 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -12,7 +12,7 @@
 
 use clone::Clone;
 use container::Container;
-use iterator::{Iterator, range};
+use iterator::Iterator;
 use option::{Option, Some, None};
 use sys;
 use unstable::raw::Repr;
@@ -92,8 +92,8 @@ pub fn append<T:Clone>(lhs: @[T], rhs: &[T]) -> @[T] {
         for x in lhs.iter() {
             push((*x).clone());
         }
-        for i in range(0u, rhs.len()) {
-            push(rhs[i].clone());
+        for elt in rhs.iter() {
+            push(elt.clone());
         }
     }
 }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index 3484a5e7d6e..84cba254dcf 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -19,7 +19,7 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, range};
+use iterator::{Iterator, IteratorUtil, FromIterator, Extendable};
 use iterator::{FilterMap, Chain, Repeat, Zip};
 use num;
 use option::{None, Option, Some};
@@ -265,8 +265,8 @@ impl<K:Hash + Eq,V> Container for HashMap<K, V> {
 impl<K:Hash + Eq,V> Mutable for HashMap<K, V> {
     /// Clear the map, removing all key-value pairs.
     fn clear(&mut self) {
-        for idx in range(0u, self.buckets.len()) {
-            self.buckets[idx] = None;
+        for bkt in self.buckets.mut_iter() {
+            *bkt = None;
         }
         self.size = 0;
     }
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 6f61d29780f..a5efae542a1 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -271,8 +271,8 @@ impl<T> TrieNode<T> {
 
 impl<T> TrieNode<T> {
     fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
-        for idx in range(0u, self.children.len()) {
-            match self.children[idx] {
+        for elt in self.children.iter() {
+            match *elt {
                 Internal(ref x) => if !x.each(|i,t| f(i,t)) { return false },
                 External(k, ref v) => if !f(&k, v) { return false },
                 Nothing => ()
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 36201dc5e82..0f6d94bb771 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -1602,8 +1602,8 @@ impl<T:Clone> OwnedCopyableVector<T> for ~[T] {
         let new_len = self.len() + rhs.len();
         self.reserve(new_len);
 
-        for i in range(0u, rhs.len()) {
-            self.push(unsafe { raw::get(rhs, i) })
+        for elt in rhs.iter() {
+            self.push((*elt).clone())
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 8964fcc5ac9cefcc55ea071142c3c81d623a52be Mon Sep 17 00:00:00 2001
From: Kevin Ballard <kevin@sb.org>
Date: Tue, 6 Aug 2013 22:34:22 -0700
Subject: Implement DoubleEndedIterator on Range

Range is now invertable as long as its element type conforms to Integer.

Remove int::range_rev() et al in favor of range().invert().
---
 src/libstd/iterator.rs                 |  35 ++++++++++++++++++++++++++++++---
 src/libstd/num/int_macros.rs           |  18 +----------------
 src/libstd/num/uint_macros.rs          |  17 +---------------
 src/libstd/run.rs                      |   6 ++----
 src/libstd/trie.rs                     |  26 +++++++++++-------------
 src/test/bench/core-map.rs             |  15 ++++++--------
 src/test/run-fail/assert-eq-macro-fail | Bin 0 -> 104051 bytes
 src/test/run-pass/num-range-rev.rs     |   4 ++--
 8 files changed, 56 insertions(+), 65 deletions(-)
 create mode 100755 src/test/run-fail/assert-eq-macro-fail

(limited to 'src/libstd')

diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index 29f54bd10fb..d10a5541e41 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -18,9 +18,9 @@ implementing the `Iterator` trait.
 */
 
 use cmp;
-use num::{Zero, One, Saturating};
+use num::{Zero, One, Integer, Saturating};
 use option::{Option, Some, None};
-use ops::{Add, Mul};
+use ops::{Add, Mul, Sub};
 use cmp::Ord;
 use clone::Clone;
 use uint;
@@ -1531,7 +1531,7 @@ pub fn range<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> Range<A> {
     Range{state: start, stop: stop, one: One::one()}
 }
 
-impl<A: Add<A, A> + Ord + Clone + One> Iterator<A> for Range<A> {
+impl<A: Add<A, A> + Ord + Clone> Iterator<A> for Range<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.state < self.stop {
@@ -1544,6 +1544,22 @@ impl<A: Add<A, A> + Ord + Clone + One> Iterator<A> for Range<A> {
     }
 }
 
+impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
+    #[inline]
+    fn next_back(&mut self) -> Option<A> {
+        if self.stop > self.state {
+            // Integer doesn't technically define this rule, but we're going to assume that every
+            // Integer is reachable from every other one by adding or subtracting enough Ones. This
+            // seems like a reasonable-enough rule that every Integer should conform to, even if it
+            // can't be statically checked.
+            self.stop = self.stop - self.one;
+            Some(self.stop.clone())
+        } else {
+            None
+        }
+    }
+}
+
 impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
@@ -2121,4 +2137,17 @@ mod tests {
         check_randacc_iter(xs.iter().cycle().take_(27), 27);
         check_randacc_iter(empty.iter().cycle(), 0);
     }
+
+    #[test]
+    fn test_double_ended_range() {
+        assert_eq!(range(11i, 14).invert().collect::<~[int]>(), ~[13i, 12, 11]);
+        for _ in range(10i, 0).invert() {
+            fail!("unreachable");
+        }
+
+        assert_eq!(range(11u, 14).invert().collect::<~[uint]>(), ~[13u, 12, 11]);
+        for _ in range(10u, 0).invert() {
+            fail!("unreachable");
+        }
+    }
 }
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 9842a570d7e..b692bedebfd 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -124,14 +124,6 @@ pub fn range_step_inclusive(start: $T, last: $T, step: $T, it: &fn($T) -> bool)
     range_step_core(start, last, step, Closed, it)
 }
 
-
-#[inline]
-/// Iterate over the range (`hi`..`lo`]
-pub fn range_rev(hi: $T, lo: $T, it: &fn($T) -> bool) -> bool {
-    if hi == min_value { return true; }
-    range_step_inclusive(hi-1, lo, -1 as $T, it)
-}
-
 impl Num for $T {}
 
 #[cfg(not(test))]
@@ -889,10 +881,6 @@ mod tests {
     fn test_ranges() {
         let mut l = ~[];
 
-        do range_rev(14,11) |i| {
-            l.push(i);
-            true
-        };
         do range_step(20,26,2) |i| {
             l.push(i);
             true
@@ -917,8 +905,7 @@ mod tests {
             l.push(i);
             true
         };
-        assert_eq!(l, ~[13,12,11,
-                        20,22,24,
+        assert_eq!(l, ~[20,22,24,
                         36,34,32,
                         max_value-2,
                         max_value-3,max_value-1,
@@ -926,9 +913,6 @@ mod tests {
                         min_value+3,min_value+1]);
 
         // None of the `fail`s should execute.
-        do range_rev(0,10) |_i| {
-            fail!(~"unreachable");
-        };
         do range_step(10,0,1) |_i| {
             fail!(~"unreachable");
         };
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index a2874c96703..29b8f29d87d 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -125,13 +125,6 @@ pub fn range_step_inclusive(start: $T, last: $T, step: $T_SIGNED, it: &fn($T) ->
     range_step_core(start, last, step, Closed, it)
 }
 
-#[inline]
-/// Iterate over the range (`hi`..`lo`]
-pub fn range_rev(hi: $T, lo: $T, it: &fn($T) -> bool) -> bool {
-    if hi == min_value { return true; }
-    range_step_inclusive(hi-1, lo, -1 as $T_SIGNED, it)
-}
-
 impl Num for $T {}
 
 #[cfg(not(test))]
@@ -654,10 +647,6 @@ mod tests {
     pub fn test_ranges() {
         let mut l = ~[];
 
-        do range_rev(14,11) |i| {
-            l.push(i);
-            true
-        };
         do range_step(20,26,2) |i| {
             l.push(i);
             true
@@ -683,8 +672,7 @@ mod tests {
             true
         };
 
-        assert_eq!(l, ~[13,12,11,
-                        20,22,24,
+        assert_eq!(l, ~[20,22,24,
                         36,34,32,
                         max_value-2,
                         max_value-3,max_value-1,
@@ -692,9 +680,6 @@ mod tests {
                         min_value+3,min_value+1]);
 
         // None of the `fail`s should execute.
-        do range_rev(0,0) |_i| {
-            fail!("unreachable");
-        };
         do range_step(10,0,1) |_i| {
             fail!("unreachable");
         };
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index ef3d881c5fe..694aa672af7 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -632,7 +632,6 @@ fn spawn_process_os(prog: &str, args: &[~str],
 
     use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
     use libc::funcs::bsd44::getdtablesize;
-    use int;
 
     mod rustrt {
         use libc::c_void;
@@ -665,10 +664,9 @@ fn spawn_process_os(prog: &str, args: &[~str],
             fail!("failure in dup3(err_fd, 2): %s", os::last_os_error());
         }
         // close all other fds
-        do int::range_rev(getdtablesize() as int, 3) |fd| {
+        for fd in range(3, getdtablesize()).invert() {
             close(fd as c_int);
-            true
-        };
+        }
 
         do with_dirp(dir) |dirp| {
             if !dirp.is_null() && chdir(dirp) == -1 {
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index a5efae542a1..5ef5526e516 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -282,13 +282,14 @@ impl<T> TrieNode<T> {
     }
 
     fn each_reverse<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
-        do uint::range_rev(self.children.len(), 0) |idx| {
-            match self.children[idx] {
-                Internal(ref x) => x.each_reverse(|i,t| f(i,t)),
-                External(k, ref v) => f(&k, v),
-                Nothing => true
+        for elt in self.children.rev_iter() {
+            match *elt {
+                Internal(ref x) => if !x.each_reverse(|i,t| f(i,t)) { return false },
+                External(k, ref v) => if !f(&k, v) { return false },
+                Nothing => ()
             }
         }
+        true
     }
 
     fn mutate_values<'a>(&'a mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
@@ -539,10 +540,9 @@ mod test_map {
     fn test_each_break() {
         let mut m = TrieMap::new();
 
-        do uint::range_rev(uint::max_value, uint::max_value - 10000) |x| {
+        for x in range(uint::max_value - 10000, uint::max_value).invert() {
             m.insert(x, x / 2);
-            true
-        };
+        }
 
         let mut n = uint::max_value - 10000;
         do m.each |k, v| {
@@ -580,10 +580,9 @@ mod test_map {
     fn test_each_reverse_break() {
         let mut m = TrieMap::new();
 
-        do uint::range_rev(uint::max_value, uint::max_value - 10000) |x| {
+        for x in range(uint::max_value - 10000, uint::max_value).invert() {
             m.insert(x, x / 2);
-            true
-        };
+        }
 
         let mut n = uint::max_value - 1;
         do m.each_reverse |k, v| {
@@ -634,10 +633,9 @@ mod test_map {
         let last = uint::max_value;
 
         let mut map = TrieMap::new();
-        do uint::range_rev(last, first) |x| {
+        for x in range(first, last).invert() {
             map.insert(x, x / 2);
-            true
-        };
+        }
 
         let mut i = 0;
         for (k, &v) in map.iter() {
diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
index cf160ca31c6..6475012e009 100644
--- a/src/test/bench/core-map.rs
+++ b/src/test/bench/core-map.rs
@@ -53,24 +53,21 @@ fn descending<M: MutableMap<uint, uint>>(map: &mut M, n_keys: uint) {
     io::println(" Descending integers:");
 
     do timed("insert") {
-        do uint::range_rev(n_keys, 0) |i| {
+        for i in range(0, n_keys).invert() {
             map.insert(i, i + 1);
-            true
-        };
+        }
     }
 
     do timed("search") {
-        do uint::range_rev(n_keys, 0) |i| {
+        for i in range(0, n_keys).invert() {
             assert_eq!(map.find(&i).unwrap(), &(i + 1));
-            true
-        };
+        }
     }
 
     do timed("remove") {
-        do uint::range_rev(n_keys, 0) |i| {
+        for i in range(0, n_keys) {
             assert!(map.remove(&i));
-            true
-        };
+        }
     }
 }
 
diff --git a/src/test/run-fail/assert-eq-macro-fail b/src/test/run-fail/assert-eq-macro-fail
new file mode 100755
index 00000000000..2841756d4a0
Binary files /dev/null and b/src/test/run-fail/assert-eq-macro-fail differ
diff --git a/src/test/run-pass/num-range-rev.rs b/src/test/run-pass/num-range-rev.rs
index 5eecbe7e03a..ea7d4a651f7 100644
--- a/src/test/run-pass/num-range-rev.rs
+++ b/src/test/run-pass/num-range-rev.rs
@@ -20,11 +20,11 @@ fn int_range(lo: int,  hi: int, it: &fn(int) -> bool) -> bool {
 }
 
 fn uint_range_rev(hi: uint, lo: uint, it: &fn(uint) -> bool) -> bool {
-    uint::range_rev(hi, lo, it)
+    range(lo, hi).invert().advance(it)
 }
 
 fn int_range_rev(hi: int,  lo: int, it: &fn(int) -> bool) -> bool {
-    int::range_rev(hi, lo, it)
+    range(lo, hi).invert().advance(it)
 }
 
 fn int_range_step(a: int, b: int, step: int, it: &fn(int) -> bool) -> bool {
-- 
cgit 1.4.1-3-g733a5


From e99eff172a11816f335153147dd0800fc4877bee Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 6 Aug 2013 23:03:31 -0700
Subject: Forbid `priv` where it has no effect

This is everywhere except struct fields and enum variants.
---
 src/libextra/fileinput.rs                          | 14 ++++++-------
 src/libextra/future.rs                             |  2 +-
 src/libextra/getopts.rs                            |  8 ++++----
 src/libextra/num/bigint.rs                         | 20 +++++++++---------
 src/libextra/stats.rs                              |  2 +-
 src/libextra/term.rs                               |  4 ++--
 src/libextra/terminfo/parm.rs                      | 12 +++++------
 src/libextra/time.rs                               |  4 ++--
 src/librustc/middle/typeck/rscope.rs               |  2 +-
 src/libstd/comm.rs                                 |  8 ++++----
 src/libstd/num/strconv.rs                          |  6 +++---
 src/libstd/run.rs                                  |  6 +++---
 src/libstd/str.rs                                  | 20 +++++++++---------
 src/libstd/str/ascii.rs                            |  6 +++---
 src/libsyntax/parse/obsolete.rs                    |  5 +++++
 src/libsyntax/parse/parser.rs                      | 24 ++++++++++++++++------
 .../run-pass/class-cast-to-trait-multiple-types.rs |  2 +-
 17 files changed, 81 insertions(+), 64 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs
index 7a36b25eac5..14b02688cff 100644
--- a/src/libextra/fileinput.rs
+++ b/src/libextra/fileinput.rs
@@ -129,27 +129,27 @@ struct FileInput_ {
     `Some(path)` is the file represented by `path`, `None` is
     `stdin`. Consumed as the files are read.
     */
-    priv files: ~[Option<Path>],
+    files: ~[Option<Path>],
     /**
     The current file: `Some(r)` for an open file, `None` before
     starting and after reading everything.
     */
-    priv current_reader: Option<@io::Reader>,
-    priv state: FileInputState,
+    current_reader: Option<@io::Reader>,
+    state: FileInputState,
 
     /**
     Used to keep track of whether we need to insert the newline at the
     end of a file that is missing it, which is needed to separate the
     last and first lines.
     */
-    priv previous_was_newline: bool
+    previous_was_newline: bool
 }
 
 // XXX: remove this when Reader has &mut self. Should be removable via
 // "self.fi." -> "self." and renaming FileInput_. Documentation above
 // will likely have to be updated to use `let mut in = ...`.
 pub struct FileInput  {
-    priv fi: @mut FileInput_
+    fi: @mut FileInput_
 }
 
 impl FileInput {
@@ -198,7 +198,7 @@ impl FileInput {
         FileInput::from_vec(pathed)
     }
 
-    priv fn current_file_eof(&self) -> bool {
+    fn current_file_eof(&self) -> bool {
         match self.fi.current_reader {
             None => false,
             Some(r) => r.eof()
@@ -240,7 +240,7 @@ impl FileInput {
     Returns `true` if it had to move to the next file and did
     so successfully.
     */
-    priv fn next_file_if_eof(&self) -> bool {
+    fn next_file_if_eof(&self) -> bool {
         match self.fi.current_reader {
             None => self.next_file(),
             Some(r) => {
diff --git a/src/libextra/future.rs b/src/libextra/future.rs
index 7d2a0658969..cc65c49d73a 100644
--- a/src/libextra/future.rs
+++ b/src/libextra/future.rs
@@ -46,7 +46,7 @@ impl<A> Drop for Future<A> {
     fn drop(&self) {}
 }
 
-priv enum FutureState<A> {
+enum FutureState<A> {
     Pending(~fn() -> A),
     Evaluating,
     Forced(A)
diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs
index 15aac8ef47c..8bd9d857d69 100644
--- a/src/libextra/getopts.rs
+++ b/src/libextra/getopts.rs
@@ -708,9 +708,9 @@ pub mod groups {
      *  Fails during iteration if the string contains a non-whitespace
      *  sequence longer than the limit.
      */
-    priv fn each_split_within<'a>(ss: &'a str,
-                                lim: uint,
-                                it: &fn(&'a str) -> bool) -> bool {
+    fn each_split_within<'a>(ss: &'a str,
+                             lim: uint,
+                             it: &fn(&'a str) -> bool) -> bool {
         // Just for fun, let's write this as an state machine:
 
         enum SplitWithinState {
@@ -778,7 +778,7 @@ pub mod groups {
     }
 
     #[test]
-    priv fn test_split_within() {
+    fn test_split_within() {
         fn t(s: &str, i: uint, u: &[~str]) {
             let mut v = ~[];
             do each_split_within(s, i) |s| { v.push(s.to_owned()); true };
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index c3737d44e38..0c8701bd0b5 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -59,13 +59,13 @@ pub mod BigDigit {
     pub static bits: uint = 32;
 
     pub static base: uint = 1 << bits;
-    priv static hi_mask: uint = (-1 as uint) << bits;
-    priv static lo_mask: uint = (-1 as uint) >> bits;
+    static hi_mask: uint = (-1 as uint) << bits;
+    static lo_mask: uint = (-1 as uint) >> bits;
 
 
-    priv fn get_hi(n: uint) -> BigDigit { (n >> bits) as BigDigit }
+    fn get_hi(n: uint) -> BigDigit { (n >> bits) as BigDigit }
 
-    priv fn get_lo(n: uint) -> BigDigit { (n & lo_mask) as BigDigit }
+    fn get_lo(n: uint) -> BigDigit { (n & lo_mask) as BigDigit }
 
     /// Split one machine sized unsigned integer into two BigDigits.
 
@@ -613,7 +613,7 @@ impl BigUint {
     }
 
 
-    priv fn shl_unit(&self, n_unit: uint) -> BigUint {
+    fn shl_unit(&self, n_unit: uint) -> BigUint {
         if n_unit == 0 || self.is_zero() { return (*self).clone(); }
 
         return BigUint::new(vec::from_elem(n_unit, ZERO_BIG_DIGIT)
@@ -621,7 +621,7 @@ impl BigUint {
     }
 
 
-    priv fn shl_bits(&self, n_bits: uint) -> BigUint {
+    fn shl_bits(&self, n_bits: uint) -> BigUint {
         if n_bits == 0 || self.is_zero() { return (*self).clone(); }
 
         let mut carry = 0;
@@ -637,7 +637,7 @@ impl BigUint {
     }
 
 
-    priv fn shr_unit(&self, n_unit: uint) -> BigUint {
+    fn shr_unit(&self, n_unit: uint) -> BigUint {
         if n_unit == 0 { return (*self).clone(); }
         if self.data.len() < n_unit { return Zero::zero(); }
         return BigUint::from_slice(
@@ -646,7 +646,7 @@ impl BigUint {
     }
 
 
-    priv fn shr_bits(&self, n_bits: uint) -> BigUint {
+    fn shr_bits(&self, n_bits: uint) -> BigUint {
         if n_bits == 0 || self.data.is_empty() { return (*self).clone(); }
 
         let mut borrow = 0;
@@ -661,7 +661,7 @@ impl BigUint {
 
 #[cfg(target_arch = "x86_64")]
 
-priv fn get_radix_base(radix: uint) -> (uint, uint) {
+fn get_radix_base(radix: uint) -> (uint, uint) {
     assert!(1 < radix && radix <= 16);
     match radix {
         2  => (4294967296, 32),
@@ -687,7 +687,7 @@ priv fn get_radix_base(radix: uint) -> (uint, uint) {
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "mips")]
 
-priv fn get_radix_base(radix: uint) -> (uint, uint) {
+fn get_radix_base(radix: uint) -> (uint, uint) {
     assert!(1 < radix && radix <= 16);
     match radix {
         2  => (65536, 16),
diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs
index 9238034cba3..881d931fe0a 100644
--- a/src/libextra/stats.rs
+++ b/src/libextra/stats.rs
@@ -223,7 +223,7 @@ impl<'self> Stats for &'self [f64] {
 
 // Helper function: extract a value representing the `pct` percentile of a sorted sample-set, using
 // linear interpolation. If samples are not sorted, return nonsensical value.
-priv fn percentile_of_sorted(sorted_samples: &[f64],
+fn percentile_of_sorted(sorted_samples: &[f64],
                              pct: f64) -> f64 {
     assert!(sorted_samples.len() != 0);
     if sorted_samples.len() == 1 {
diff --git a/src/libextra/term.rs b/src/libextra/term.rs
index 2173eb838e5..d0412b8954d 100644
--- a/src/libextra/term.rs
+++ b/src/libextra/term.rs
@@ -75,7 +75,7 @@ pub mod attr {
 }
 
 #[cfg(not(target_os = "win32"))]
-priv fn cap_for_attr(attr: attr::Attr) -> &'static str {
+fn cap_for_attr(attr: attr::Attr) -> &'static str {
     match attr {
         attr::Bold               => "bold",
         attr::Dim                => "dim",
@@ -234,7 +234,7 @@ impl Terminal {
         }
     }
 
-    priv fn dim_if_necessary(&self, color: color::Color) -> color::Color {
+    fn dim_if_necessary(&self, color: color::Color) -> color::Color {
         if color >= self.num_colors && color >= 8 && color < 16 {
             color-8
         } else { color }
diff --git a/src/libextra/terminfo/parm.rs b/src/libextra/terminfo/parm.rs
index b619e0f33b6..0929575ee9e 100644
--- a/src/libextra/terminfo/parm.rs
+++ b/src/libextra/terminfo/parm.rs
@@ -430,7 +430,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
 }
 
 #[deriving(Eq)]
-priv struct Flags {
+struct Flags {
     width: uint,
     precision: uint,
     alternate: bool,
@@ -440,13 +440,13 @@ priv struct Flags {
 }
 
 impl Flags {
-    priv fn new() -> Flags {
+    fn new() -> Flags {
         Flags{ width: 0, precision: 0, alternate: false,
                left: false, sign: false, space: false }
     }
 }
 
-priv enum FormatOp {
+enum FormatOp {
     FormatDigit,
     FormatOctal,
     FormatHex,
@@ -455,7 +455,7 @@ priv enum FormatOp {
 }
 
 impl FormatOp {
-    priv fn from_char(c: char) -> FormatOp {
+    fn from_char(c: char) -> FormatOp {
         match c {
             'd' => FormatDigit,
             'o' => FormatOctal,
@@ -465,7 +465,7 @@ impl FormatOp {
             _ => fail!("bad FormatOp char")
         }
     }
-    priv fn to_char(self) -> char {
+    fn to_char(self) -> char {
         match self {
             FormatDigit => 'd',
             FormatOctal => 'o',
@@ -476,7 +476,7 @@ impl FormatOp {
     }
 }
 
-priv fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
+fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
     let mut s = match val {
         Number(d) => {
             match op {
diff --git a/src/libextra/time.rs b/src/libextra/time.rs
index efc3dc87adc..f6a5fd98234 100644
--- a/src/libextra/time.rs
+++ b/src/libextra/time.rs
@@ -254,7 +254,7 @@ impl Tm {
     }
 }
 
-priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
+fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
     fn match_str(s: &str, pos: uint, needle: &str) -> bool {
         let mut i = pos;
         for ch in needle.byte_iter() {
@@ -687,7 +687,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
     }
 }
 
-priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
+fn do_strftime(format: &str, tm: &Tm) -> ~str {
     fn parse_type(ch: char, tm: &Tm) -> ~str {
         //FIXME (#2350): Implement missing types.
       let die = || fmt!("strftime: can't understand this format %c ", ch);
diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs
index bbcf42b1c5d..c9e2b8dd37b 100644
--- a/src/librustc/middle/typeck/rscope.rs
+++ b/src/librustc/middle/typeck/rscope.rs
@@ -215,7 +215,7 @@ impl region_scope for MethodRscope {
 pub struct type_rscope(Option<RegionParameterization>);
 
 impl type_rscope {
-    priv fn replacement(&self) -> ty::Region {
+    fn replacement(&self) -> ty::Region {
         if self.is_some() {
             ty::re_bound(ty::br_self)
         } else {
diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 4356f1143da..a4de10f8c77 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -314,7 +314,7 @@ mod pipesy {
 
     #[allow(non_camel_case_types)]
     pub mod oneshot {
-        priv use std::kinds::Send;
+        use std::kinds::Send;
         use ptr::to_mut_unsafe_ptr;
 
         pub fn init<T: Send>() -> (server::Oneshot<T>, client::Oneshot<T>) {
@@ -341,7 +341,7 @@ mod pipesy {
         #[allow(non_camel_case_types)]
         pub mod client {
 
-            priv use std::kinds::Send;
+            use std::kinds::Send;
 
             #[allow(non_camel_case_types)]
             pub fn try_send<T: Send>(pipe: Oneshot<T>, x_0: T) ->
@@ -489,7 +489,7 @@ mod pipesy {
 
     #[allow(non_camel_case_types)]
     pub mod streamp {
-        priv use std::kinds::Send;
+        use std::kinds::Send;
 
         pub fn init<T: Send>() -> (server::Open<T>, client::Open<T>) {
             pub use std::pipes::HasBuffer;
@@ -501,7 +501,7 @@ mod pipesy {
 
         #[allow(non_camel_case_types)]
         pub mod client {
-            priv use std::kinds::Send;
+            use std::kinds::Send;
 
             #[allow(non_camel_case_types)]
             pub fn try_data<T: Send>(pipe: Open<T>, x_0: T) ->
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index 7ab3c81b61f..1f22343ad9c 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -422,9 +422,9 @@ pub fn float_to_str_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Float+Round+
 
 // Some constants for from_str_bytes_common's input validation,
 // they define minimum radix values for which the character is a valid digit.
-priv static DIGIT_P_RADIX: uint = ('p' as uint) - ('a' as uint) + 11u;
-priv static DIGIT_I_RADIX: uint = ('i' as uint) - ('a' as uint) + 11u;
-priv static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
+static DIGIT_P_RADIX: uint = ('p' as uint) - ('a' as uint) + 11u;
+static DIGIT_I_RADIX: uint = ('i' as uint) - ('a' as uint) + 11u;
+static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
 
 /**
  * Parses a byte slice as a number. This is meant to
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index 694aa672af7..99cf96eaae2 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -761,14 +761,14 @@ fn with_dirp<T>(d: Option<&Path>,
 }
 
 #[cfg(windows)]
-priv fn free_handle(handle: *()) {
+fn free_handle(handle: *()) {
     unsafe {
         libc::funcs::extra::kernel32::CloseHandle(cast::transmute(handle));
     }
 }
 
 #[cfg(unix)]
-priv fn free_handle(_handle: *()) {
+fn free_handle(_handle: *()) {
     // unix has no process handle object, just a pid
 }
 
@@ -823,7 +823,7 @@ pub fn process_output(prog: &str, args: &[~str]) -> ProcessOutput {
  * operate on a none-existant process or, even worse, on a newer process
  * with the same id.
  */
-priv fn waitpid(pid: pid_t) -> int {
+fn waitpid(pid: pid_t) -> int {
     return waitpid_os(pid);
 
     #[cfg(windows)]
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index c4bd2c5435a..fa75916fb86 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -738,7 +738,7 @@ pub fn count_bytes<'b>(s: &'b str, start: uint, n: uint) -> uint {
 }
 
 // https://tools.ietf.org/html/rfc3629
-priv static UTF8_CHAR_WIDTH: [u8, ..256] = [
+static UTF8_CHAR_WIDTH: [u8, ..256] = [
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
@@ -781,15 +781,15 @@ macro_rules! utf8_acc_cont_byte(
 )
 
 // UTF-8 tags and ranges
-priv static TAG_CONT_U8: u8 = 128u8;
-priv static TAG_CONT: uint = 128u;
-priv static MAX_ONE_B: uint = 128u;
-priv static TAG_TWO_B: uint = 192u;
-priv static MAX_TWO_B: uint = 2048u;
-priv static TAG_THREE_B: uint = 224u;
-priv static MAX_THREE_B: uint = 65536u;
-priv static TAG_FOUR_B: uint = 240u;
-priv static MAX_UNICODE: uint = 1114112u;
+static TAG_CONT_U8: u8 = 128u8;
+static TAG_CONT: uint = 128u;
+static MAX_ONE_B: uint = 128u;
+static TAG_TWO_B: uint = 192u;
+static MAX_TWO_B: uint = 2048u;
+static TAG_THREE_B: uint = 224u;
+static MAX_THREE_B: uint = 65536u;
+static TAG_FOUR_B: uint = 240u;
+static MAX_UNICODE: uint = 1114112u;
 
 /// Unsafe operations
 pub mod raw {
diff --git a/src/libstd/str/ascii.rs b/src/libstd/str/ascii.rs
index 1be4d07dfa4..6ededb02107 100644
--- a/src/libstd/str/ascii.rs
+++ b/src/libstd/str/ascii.rs
@@ -274,7 +274,7 @@ pub fn to_ascii_lower(string: &str) -> ~str {
 }
 
 #[inline]
-priv fn map_bytes(string: &str, map: &'static [u8]) -> ~str {
+fn map_bytes(string: &str, map: &'static [u8]) -> ~str {
     let len = string.len();
     let mut result = str::with_capacity(len);
     unsafe {
@@ -298,7 +298,7 @@ pub fn eq_ignore_ascii_case(a: &str, b: &str) -> bool {
         |(byte_a, byte_b)| ASCII_LOWER_MAP[*byte_a] == ASCII_LOWER_MAP[*byte_b])
 }
 
-priv static ASCII_LOWER_MAP: &'static [u8] = &[
+static ASCII_LOWER_MAP: &'static [u8] = &[
     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
@@ -333,7 +333,7 @@ priv static ASCII_LOWER_MAP: &'static [u8] = &[
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
 ];
 
-priv static ASCII_UPPER_MAP: &'static [u8] = &[
+static ASCII_UPPER_MAP: &'static [u8] = &[
     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index ec956f61863..dda5e990221 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -64,6 +64,7 @@ pub enum ObsoleteSyntax {
     ObsoleteMutWithMultipleBindings,
     ObsoleteExternVisibility,
     ObsoleteUnsafeExternFn,
+    ObsoletePrivVisibility,
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -253,6 +254,10 @@ impl ParserObsoleteMethods for Parser {
                 "external functions are always unsafe; remove the `unsafe` \
                  keyword"
             ),
+            ObsoletePrivVisibility => (
+                "`priv` not necessary",
+                "an item without a visibility qualifier is private by default"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 4902c4587ac..7d6dce22fb7 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -85,7 +85,7 @@ use parse::obsolete::{ObsoleteConstItem, ObsoleteFixedLengthVectorType};
 use parse::obsolete::{ObsoleteNamedExternModule, ObsoleteMultipleLocalDecl};
 use parse::obsolete::{ObsoleteMutWithMultipleBindings};
 use parse::obsolete::{ObsoleteExternVisibility, ObsoleteUnsafeExternFn};
-use parse::obsolete::{ParserObsoleteMethods};
+use parse::obsolete::{ParserObsoleteMethods, ObsoletePrivVisibility};
 use parse::token::{can_begin_expr, get_ident_interner, ident_to_str, is_ident};
 use parse::token::{is_ident_or_path};
 use parse::token::{is_plain_ident, INTERPOLATED, keywords, special_idents};
@@ -814,7 +814,7 @@ impl Parser {
             let attrs = p.parse_outer_attributes();
             let lo = p.span.lo;
 
-            let vis = p.parse_visibility();
+            let vis = p.parse_non_priv_visibility();
             let pur = p.parse_fn_purity();
             // NB: at the moment, trait methods are public by default; this
             // could change.
@@ -3608,7 +3608,7 @@ impl Parser {
         let attrs = self.parse_outer_attributes();
         let lo = self.span.lo;
 
-        let visa = self.parse_visibility();
+        let visa = self.parse_non_priv_visibility();
         let pur = self.parse_fn_purity();
         let ident = self.parse_ident();
         let generics = self.parse_generics();
@@ -3871,6 +3871,18 @@ impl Parser {
         else { inherited }
     }
 
+    // parse visibility, but emits an obsolete error if it's private
+    fn parse_non_priv_visibility(&self) -> visibility {
+        match self.parse_visibility() {
+            public => public,
+            inherited => inherited,
+            private => {
+                self.obsolete(*self.last_span, ObsoletePrivVisibility);
+                inherited
+            }
+        }
+    }
+
     fn parse_staticness(&self) -> bool {
         if self.eat_keyword(keywords::Static) {
             self.obsolete(*self.last_span, ObsoleteStaticMethod);
@@ -4063,7 +4075,7 @@ impl Parser {
     // parse a function declaration from a foreign module
     fn parse_item_foreign_fn(&self,  attrs: ~[Attribute]) -> @foreign_item {
         let lo = self.span.lo;
-        let vis = self.parse_visibility();
+        let vis = self.parse_non_priv_visibility();
 
         // Parse obsolete purity.
         let purity = self.parse_fn_purity();
@@ -4443,7 +4455,7 @@ impl Parser {
         maybe_whole!(iovi self, nt_item);
         let lo = self.span.lo;
 
-        let visibility = self.parse_visibility();
+        let visibility = self.parse_non_priv_visibility();
 
         // must be a view item:
         if self.eat_keyword(keywords::Use) {
@@ -4575,7 +4587,7 @@ impl Parser {
         maybe_whole!(iovi self, nt_item);
         let lo = self.span.lo;
 
-        let visibility = self.parse_visibility();
+        let visibility = self.parse_non_priv_visibility();
 
         if (self.is_keyword(keywords::Const) || self.is_keyword(keywords::Static)) {
             // FOREIGN CONST ITEM
diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs
index a5d7ba2c1aa..a134ffe49fd 100644
--- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs
+++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs
@@ -21,7 +21,7 @@ struct dog {
 }
 
 impl dog {
-    priv fn bark(&self) -> int {
+    fn bark(&self) -> int {
       info!("Woof %u %d", *self.barks, *self.volume);
       *self.barks += 1u;
       if *self.barks % 3u == 0u {
-- 
cgit 1.4.1-3-g733a5


From 3db9dc1dfd8038862b06b712ece75fd7d17339af Mon Sep 17 00:00:00 2001
From: Jordi Boggiano <j.boggiano@seld.be>
Date: Tue, 6 Aug 2013 22:13:26 +0200
Subject: Document rand module with more emphasis on cryptographic security

---
 src/libstd/rand.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 4ef524d7715..4408e5e1f27 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -610,6 +610,11 @@ impl<R: Rng> RngUtil for R {
 }
 
 /// Create a random number generator with a default algorithm and seed.
+///
+/// It returns the cryptographically-safest `Rng` algorithm currently
+/// available in Rust. If you require a specifically seeded `Rng` for
+/// consistency over time you should pick one algorithm and create the
+/// `Rng` yourself.
 pub fn rng() -> IsaacRng {
     IsaacRng::new()
 }
@@ -619,6 +624,8 @@ static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN;
 
 /// A random number generator that uses the [ISAAC
 /// algorithm](http://en.wikipedia.org/wiki/ISAAC_%28cipher%29).
+///
+/// The ISAAC algorithm is suitable for cryptographic purposes.
 pub struct IsaacRng {
     priv cnt: u32,
     priv rsl: [u32, .. RAND_SIZE],
@@ -794,8 +801,11 @@ impl Rng for IsaacRng {
 }
 
 /// An [Xorshift random number
-/// generator](http://en.wikipedia.org/wiki/Xorshift). Not suitable for
-/// cryptographic purposes.
+/// generator](http://en.wikipedia.org/wiki/Xorshift).
+///
+/// The Xorshift algorithm is not suitable for cryptographic purposes
+/// but is very fast. If you do not know for sure that it fits your
+/// requirements, use a more secure one such as `IsaacRng`.
 pub struct XorShiftRng {
     priv x: u32,
     priv y: u32,
-- 
cgit 1.4.1-3-g733a5


From 403c52d2ae1a59dea1a3b04ad794a66bd687d067 Mon Sep 17 00:00:00 2001
From: Jordi Boggiano <j.boggiano@seld.be>
Date: Tue, 6 Aug 2013 22:14:32 +0200
Subject: Add weak_rng to get a random algo that puts more emphasis on speed
 than security

---
 src/libstd/rand.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'src/libstd')

diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 4408e5e1f27..5f8fa9fddbc 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -619,6 +619,16 @@ pub fn rng() -> IsaacRng {
     IsaacRng::new()
 }
 
+/// Create a weak random number generator with a default algorithm and seed.
+///
+/// It returns the fatest `Rng` algorithm currently available in Rust without
+/// consideration for cryptography or security. If you require a specifically
+/// seeded `Rng` for consistency over time you should pick one algorithm and
+/// create the `Rng` yourself.
+pub fn weak_rng() -> XorShiftRng {
+    XorShiftRng::new()
+}
+
 static RAND_SIZE_LEN: u32 = 8;
 static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN;
 
-- 
cgit 1.4.1-3-g733a5


From 8460dac909fc10b6bf0216d0123735c283cc1391 Mon Sep 17 00:00:00 2001
From: Huon Wilson <dbau.pp+github@gmail.com>
Date: Tue, 6 Aug 2013 22:19:33 +1000
Subject: std: add missing #[inline] annotation to the f64 arithmetic trait
 impls.

---
 src/libstd/num/f64.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/libstd')

diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index c7db60e6fd2..60527905779 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -278,18 +278,22 @@ impl One for f64 {
 
 #[cfg(not(test))]
 impl Add<f64,f64> for f64 {
+    #[inline]
     fn add(&self, other: &f64) -> f64 { *self + *other }
 }
 #[cfg(not(test))]
 impl Sub<f64,f64> for f64 {
+    #[inline]
     fn sub(&self, other: &f64) -> f64 { *self - *other }
 }
 #[cfg(not(test))]
 impl Mul<f64,f64> for f64 {
+    #[inline]
     fn mul(&self, other: &f64) -> f64 { *self * *other }
 }
 #[cfg(not(test))]
 impl Div<f64,f64> for f64 {
+    #[inline]
     fn div(&self, other: &f64) -> f64 { *self / *other }
 }
 #[cfg(not(test))]
-- 
cgit 1.4.1-3-g733a5


From 8ebdb37fd24435d08451625656cc53ebc814c3fa Mon Sep 17 00:00:00 2001
From: Ben Blum <bblum@andrew.cmu.edu>
Date: Mon, 5 Aug 2013 19:58:10 -0400
Subject: fix recv_ready for Port to take &self and not need to return a tuple.
 Close #8192.

---
 src/libstd/rt/comm.rs   | 29 +++++++++++++++++++++++++----
 src/libstd/rt/select.rs |  4 +---
 2 files changed, 26 insertions(+), 7 deletions(-)

(limited to 'src/libstd')

diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index 0cf223f3029..6dc44dd1193 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -508,7 +508,11 @@ impl<T> Peekable<T> for Port<T> {
     }
 }
 
-impl<T> Select for Port<T> {
+// XXX: Kind of gross. A Port<T> should be selectable so you can make an array
+// of them, but a &Port<T> should also be selectable so you can select2 on it
+// alongside a PortOne<U> without passing the port by value in recv_ready.
+
+impl<'self, T> Select for &'self Port<T> {
     #[inline]
     fn optimistic_check(&mut self) -> bool {
         do self.next.with_mut_ref |pone| { pone.optimistic_check() }
@@ -526,12 +530,29 @@ impl<T> Select for Port<T> {
     }
 }
 
-impl<T> SelectPort<(T, Port<T>)> for Port<T> {
-    fn recv_ready(self) -> Option<(T, Port<T>)> {
+impl<T> Select for Port<T> {
+    #[inline]
+    fn optimistic_check(&mut self) -> bool {
+        (&*self).optimistic_check()
+    }
+
+    #[inline]
+    fn block_on(&mut self, sched: &mut Scheduler, task: BlockedTask) -> bool {
+        (&*self).block_on(sched, task)
+    }
+
+    #[inline]
+    fn unblock_from(&mut self) -> bool {
+        (&*self).unblock_from()
+    }
+}
+
+impl<'self, T> SelectPort<T> for &'self Port<T> {
+    fn recv_ready(self) -> Option<T> {
         match self.next.take().recv_ready() {
             Some(StreamPayload { val, next }) => {
                 self.next.put_back(next);
-                Some((val, self))
+                Some(val)
             }
             None => None
         }
diff --git a/src/libstd/rt/select.rs b/src/libstd/rt/select.rs
index 006b777b71b..84ce36c3e6b 100644
--- a/src/libstd/rt/select.rs
+++ b/src/libstd/rt/select.rs
@@ -199,9 +199,7 @@ mod test {
                 // get it back out
                 util::swap(port.get_mut_ref(), &mut ports[index]);
                 // NB. Not recv(), because optimistic_check randomly fails.
-                let (data, new_port) = port.take_unwrap().recv_ready().unwrap();
-                assert!(data == 31337);
-                port = Some(new_port);
+                assert!(port.get_ref().recv_ready().unwrap() == 31337);
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From fb1575bcc4fdcae1be5654d630d2b3ac9ebc9712 Mon Sep 17 00:00:00 2001
From: Ben Blum <bblum@andrew.cmu.edu>
Date: Mon, 5 Aug 2013 20:14:20 -0400
Subject: (cleanup) Improve rtabort message for atomic-sleep.

---
 src/libstd/rt/kill.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/libstd')

diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 789c7531eca..b3e81d4b7b2 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -590,7 +590,8 @@ impl Death {
     #[inline]
     pub fn assert_may_sleep(&self) {
         if self.wont_sleep != 0 {
-            rtabort!("illegal atomic-sleep: can't deschedule inside atomically()");
+            rtabort!("illegal atomic-sleep: attempt to reschedule while \
+                      using an Exclusive or LittleLock");
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From af2e03998d4d06f2781ca72ec005f6913148f8bb Mon Sep 17 00:00:00 2001
From: toddaaro <github@opprobrio.us>
Date: Mon, 5 Aug 2013 13:06:24 -0700
Subject: Enabled workstealing in the scheduler. Previously we had one global
 work queue shared by each scheduler. Now there is a separate work queue for
 each scheduler, and work is "stolen" from other queues when it is exhausted
 locally.

---
 src/libstd/rt/comm.rs                    |   7 +-
 src/libstd/rt/mod.rs                     |  32 +++++--
 src/libstd/rt/sched.rs                   | 159 ++++++++++++++++++++++---------
 src/libstd/rt/select.rs                  |   2 +
 src/libstd/rt/test.rs                    |  18 +++-
 src/libstd/task/spawn.rs                 |   9 +-
 src/test/bench/rt-messaging-ping-pong.rs |  82 ++++++++++++++++
 src/test/bench/rt-parfib.rs              |  49 ++++++++++
 src/test/bench/rt-spawn-rate.rs          |  33 +++++++
 9 files changed, 328 insertions(+), 63 deletions(-)
 create mode 100644 src/test/bench/rt-messaging-ping-pong.rs
 create mode 100644 src/test/bench/rt-parfib.rs
 create mode 100644 src/test/bench/rt-spawn-rate.rs

(limited to 'src/libstd')

diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index 0cf223f3029..33b4b307af8 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -225,9 +225,10 @@ impl<T> Select for PortOne<T> {
     fn optimistic_check(&mut self) -> bool {
         // The optimistic check is never necessary for correctness. For testing
         // purposes, making it randomly return false simulates a racing sender.
-        use rand::{Rand, rng};
-        let mut rng = rng();
-        let actually_check = Rand::rand(&mut rng);
+        use rand::{Rand};
+        let actually_check = do Local::borrow::<Scheduler, bool> |sched| {
+            Rand::rand(&mut sched.rng)
+        };
         if actually_check {
             unsafe { (*self.packet()).state.load(Acquire) == STATE_ONE }
         } else {
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 147c75e5c41..01a52892f63 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -63,8 +63,7 @@ Several modules in `core` are clients of `rt`:
 use cell::Cell;
 use clone::Clone;
 use container::Container;
-use iter::Times;
-use iterator::{Iterator, IteratorUtil};
+use iterator::{Iterator, IteratorUtil, range};
 use option::{Some, None};
 use ptr::RawPtr;
 use rt::local::Local;
@@ -247,11 +246,16 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
 
     let main = Cell::new(main);
 
-    // The shared list of sleeping schedulers. Schedulers wake each other
-    // occassionally to do new work.
+    // The shared list of sleeping schedulers.
     let sleepers = SleeperList::new();
-    // The shared work queue. Temporary until work stealing is implemented.
-    let work_queue = WorkQueue::new();
+
+    // Create a work queue for each scheduler, ntimes. Create an extra
+    // for the main thread if that flag is set. We won't steal from it.
+    let mut work_queues = ~[];
+    for _ in range(0u, nscheds) {
+        let work_queue: WorkQueue<~Task> = WorkQueue::new();
+        work_queues.push(work_queue);
+    }
 
     // The schedulers.
     let mut scheds = ~[];
@@ -259,12 +263,15 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     // sent the Shutdown message to terminate the schedulers.
     let mut handles = ~[];
 
-    do nscheds.times {
+    for i in range(0u, nscheds) {
         rtdebug!("inserting a regular scheduler");
 
         // Every scheduler is driven by an I/O event loop.
         let loop_ = ~UvEventLoop::new();
-        let mut sched = ~Scheduler::new(loop_, work_queue.clone(), sleepers.clone());
+        let mut sched = ~Scheduler::new(loop_,
+                                        work_queues[i].clone(),
+                                        work_queues.clone(),
+                                        sleepers.clone());
         let handle = sched.make_handle();
 
         scheds.push(sched);
@@ -280,9 +287,14 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
         let friend_handle = friend_sched.make_handle();
         scheds.push(friend_sched);
 
+        // This scheduler needs a queue that isn't part of the stealee
+        // set.
+        let work_queue = WorkQueue::new();
+
         let main_loop = ~UvEventLoop::new();
         let mut main_sched = ~Scheduler::new_special(main_loop,
-                                                     work_queue.clone(),
+                                                     work_queue,
+                                                     work_queues.clone(),
                                                      sleepers.clone(),
                                                      false,
                                                      Some(friend_handle));
@@ -371,7 +383,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
         let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool, None,
                                                   home, main.take());
         main_task.death.on_exit = Some(on_exit.take());
-        rtdebug!("boostrapping main_task");
+        rtdebug!("bootstrapping main_task");
 
         main_sched.bootstrap(main_task);
     }
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 990e1a4a3de..ce4e64c47d2 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -13,7 +13,6 @@ use option::{Option, Some, None};
 use cast::{transmute, transmute_mut_region, transmute_mut_unsafe};
 use clone::Clone;
 use unstable::raw;
-
 use super::sleeper_list::SleeperList;
 use super::work_queue::WorkQueue;
 use super::stack::{StackPool};
@@ -28,6 +27,9 @@ use rt::rtio::RemoteCallback;
 use rt::metrics::SchedMetrics;
 use borrow::{to_uint};
 use cell::Cell;
+use rand::{XorShiftRng, RngUtil};
+use iterator::{range};
+use vec::{OwnedVector};
 
 /// The Scheduler is responsible for coordinating execution of Coroutines
 /// on a single thread. When the scheduler is running it is owned by
@@ -37,9 +39,11 @@ use cell::Cell;
 /// XXX: This creates too many callbacks to run_sched_once, resulting
 /// in too much allocation and too many events.
 pub struct Scheduler {
-    /// A queue of available work. Under a work-stealing policy there
-    /// is one per Scheduler.
-    work_queue: WorkQueue<~Task>,
+    /// There are N work queues, one per scheduler.
+    priv work_queue: WorkQueue<~Task>,
+    /// Work queues for the other schedulers. These are created by
+    /// cloning the core work queues.
+    work_queues: ~[WorkQueue<~Task>],
     /// The queue of incoming messages from other schedulers.
     /// These are enqueued by SchedHandles after which a remote callback
     /// is triggered to handle the message.
@@ -70,7 +74,10 @@ pub struct Scheduler {
     run_anything: bool,
     /// If the scheduler shouldn't run some tasks, a friend to send
     /// them to.
-    friend_handle: Option<SchedHandle>
+    friend_handle: Option<SchedHandle>,
+    /// A fast XorShift rng for scheduler use
+    rng: XorShiftRng
+
 }
 
 pub struct SchedHandle {
@@ -97,10 +104,13 @@ impl Scheduler {
 
     pub fn new(event_loop: ~EventLoopObject,
                work_queue: WorkQueue<~Task>,
+               work_queues: ~[WorkQueue<~Task>],
                sleeper_list: SleeperList)
         -> Scheduler {
 
-        Scheduler::new_special(event_loop, work_queue, sleeper_list, true, None)
+        Scheduler::new_special(event_loop, work_queue,
+                               work_queues,
+                               sleeper_list, true, None)
 
     }
 
@@ -108,6 +118,7 @@ impl Scheduler {
     // task field is None.
     pub fn new_special(event_loop: ~EventLoopObject,
                        work_queue: WorkQueue<~Task>,
+                       work_queues: ~[WorkQueue<~Task>],
                        sleeper_list: SleeperList,
                        run_anything: bool,
                        friend: Option<SchedHandle>)
@@ -120,12 +131,14 @@ impl Scheduler {
             no_sleep: false,
             event_loop: event_loop,
             work_queue: work_queue,
+            work_queues: work_queues,
             stack_pool: StackPool::new(),
             sched_task: None,
             cleanup_job: None,
             metrics: SchedMetrics::new(),
             run_anything: run_anything,
-            friend_handle: friend
+            friend_handle: friend,
+            rng: XorShiftRng::new()
         }
     }
 
@@ -248,7 +261,7 @@ impl Scheduler {
 
         // Second activity is to try resuming a task from the queue.
 
-        let result = sched.resume_task_from_queue();
+        let result = sched.do_work();
         let mut sched = match result {
             Some(sched) => {
                 // Failed to dequeue a task, so we return.
@@ -415,47 +428,98 @@ impl Scheduler {
         }
     }
 
-    // Resume a task from the queue - but also take into account that
-    // it might not belong here.
+    // Workstealing: In this iteration of the runtime each scheduler
+    // thread has a distinct work queue. When no work is available
+    // locally, make a few attempts to steal work from the queues of
+    // other scheduler threads. If a few steals fail we end up in the
+    // old "no work" path which is fine.
+
+    // First step in the process is to find a task. This function does
+    // that by first checking the local queue, and if there is no work
+    // there, trying to steal from the remote work queues.
+    fn find_work(&mut self) -> Option<~Task> {
+        rtdebug!("scheduler looking for work");
+        match self.work_queue.pop() {
+            Some(task) => {
+                rtdebug!("found a task locally");
+                return Some(task)
+            }
+            None => {
+                // Our naive stealing, try kinda hard.
+                rtdebug!("scheduler trying to steal");
+                let _len = self.work_queues.len();
+                return self.try_steals(2);
+            }
+        }
+    }
+
+    // With no backoff try stealing n times from the queues the
+    // scheduler knows about. This naive implementation can steal from
+    // our own queue or from other special schedulers.
+    fn try_steals(&mut self, n: uint) -> Option<~Task> {
+        for _ in range(0, n) {
+            let index = self.rng.gen_uint_range(0, self.work_queues.len());
+            let work_queues = &mut self.work_queues;
+            match work_queues[index].steal() {
+                Some(task) => {
+                    rtdebug!("found task by stealing"); return Some(task)
+                }
+                None => ()
+            }
+        };
+        rtdebug!("giving up on stealing");
+        return None;
+    }
 
-    // If we perform a scheduler action we give away the scheduler ~
-    // pointer, if it is still available we return it.
+    // Given a task, execute it correctly.
+    fn process_task(~self, task: ~Task) -> Option<~Scheduler> {
+        let mut this = self;
+        let mut task = task;
 
-    fn resume_task_from_queue(~self) -> Option<~Scheduler> {
+        rtdebug!("processing a task");
 
+        let home = task.take_unwrap_home();
+        match home {
+            Sched(home_handle) => {
+                if home_handle.sched_id != this.sched_id() {
+                    rtdebug!("sending task home");
+                    task.give_home(Sched(home_handle));
+                    Scheduler::send_task_home(task);
+                    return Some(this);
+                } else {
+                    rtdebug!("running task here");
+                    task.give_home(Sched(home_handle));
+                    this.resume_task_immediately(task);
+                    return None;
+                }
+            }
+            AnySched if this.run_anything => {
+                rtdebug!("running anysched task here");
+                task.give_home(AnySched);
+                this.resume_task_immediately(task);
+                return None;
+            }
+            AnySched => {
+                rtdebug!("sending task to friend");
+                task.give_home(AnySched);
+                this.send_to_friend(task);
+                return Some(this);
+            }
+        }
+    }
+
+    // Bundle the helpers together.
+    fn do_work(~self) -> Option<~Scheduler> {
         let mut this = self;
 
-        match this.work_queue.pop() {
+        rtdebug!("scheduler calling do work");
+        match this.find_work() {
             Some(task) => {
-                let mut task = task;
-                let home = task.take_unwrap_home();
-                match home {
-                    Sched(home_handle) => {
-                        if home_handle.sched_id != this.sched_id() {
-                            task.give_home(Sched(home_handle));
-                            Scheduler::send_task_home(task);
-                            return Some(this);
-                        } else {
-                            this.event_loop.callback(Scheduler::run_sched_once);
-                            task.give_home(Sched(home_handle));
-                            this.resume_task_immediately(task);
-                            return None;
-                        }
-                    }
-                    AnySched if this.run_anything => {
-                        this.event_loop.callback(Scheduler::run_sched_once);
-                        task.give_home(AnySched);
-                        this.resume_task_immediately(task);
-                        return None;
-                    }
-                    AnySched => {
-                        task.give_home(AnySched);
-                        this.send_to_friend(task);
-                        return Some(this);
-                    }
-                }
+                rtdebug!("found some work! processing the task");
+                return this.process_task(task);
             }
             None => {
+                rtdebug!("no work was found, returning the scheduler struct");
                 return Some(this);
             }
         }
@@ -711,7 +775,6 @@ impl Scheduler {
             GiveTask(task, f) => f.to_fn()(self, task)
         }
     }
-
 }
 
 // The cases for the below function.
@@ -745,6 +808,8 @@ impl ClosureConverter for UnsafeTaskReceiver {
 
 #[cfg(test)]
 mod test {
+    extern mod extra;
+
     use prelude::*;
     use rt::test::*;
     use unstable::run_in_bare_thread;
@@ -862,12 +927,15 @@ mod test {
         do run_in_bare_thread {
 
             let sleepers = SleeperList::new();
-            let work_queue = WorkQueue::new();
+            let normal_queue = WorkQueue::new();
+            let special_queue = WorkQueue::new();
+            let queues = ~[normal_queue.clone(), special_queue.clone()];
 
             // Our normal scheduler
             let mut normal_sched = ~Scheduler::new(
                 ~UvEventLoop::new(),
-                work_queue.clone(),
+                normal_queue,
+                queues.clone(),
                 sleepers.clone());
 
             let normal_handle = Cell::new(normal_sched.make_handle());
@@ -877,7 +945,8 @@ mod test {
             // Our special scheduler
             let mut special_sched = ~Scheduler::new_special(
                 ~UvEventLoop::new(),
-                work_queue.clone(),
+                special_queue.clone(),
+                queues.clone(),
                 sleepers.clone(),
                 false,
                 Some(friend_handle));
diff --git a/src/libstd/rt/select.rs b/src/libstd/rt/select.rs
index 006b777b71b..07f8ca77d9d 100644
--- a/src/libstd/rt/select.rs
+++ b/src/libstd/rt/select.rs
@@ -182,6 +182,7 @@ mod test {
     fn select_stream() {
         use util;
         use comm::GenericChan;
+        use iter::Times;
 
         // Sends 10 buffered packets, and uses select to retrieve them all.
         // Puts the port in a different spot in the vector each time.
@@ -265,6 +266,7 @@ mod test {
 
         fn select_racing_senders_helper(killable: bool, send_on_chans: ~[uint]) {
             use rt::test::spawntask_random;
+            use iter::Times;
 
             do run_in_newsched_task {
                 // A bit of stress, since ordinarily this is just smoke and mirrors.
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 792ea5eb33f..92366d5187f 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -15,8 +15,8 @@ use cell::Cell;
 use clone::Clone;
 use container::Container;
 use iterator::{Iterator, range};
-use vec::{OwnedVector, MutableVector};
 use super::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
+use vec::{OwnedVector, MutableVector, ImmutableVector};
 use rt::sched::Scheduler;
 use unstable::run_in_bare_thread;
 use rt::thread::Thread;
@@ -29,8 +29,12 @@ use result::{Result, Ok, Err};
 
 pub fn new_test_uv_sched() -> Scheduler {
 
+    let queue = WorkQueue::new();
+    let queues = ~[queue.clone()];
+
     let mut sched = Scheduler::new(~UvEventLoop::new(),
-                                   WorkQueue::new(),
+                                   queue,
+                                   queues,
                                    SleeperList::new());
 
     // Don't wait for the Shutdown message
@@ -164,15 +168,21 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         };
 
         let sleepers = SleeperList::new();
-        let work_queue = WorkQueue::new();
 
         let mut handles = ~[];
         let mut scheds = ~[];
+        let mut work_queues = ~[];
 
         for _ in range(0u, nthreads) {
+            let work_queue = WorkQueue::new();
+            work_queues.push(work_queue);
+        }
+
+        for i in range(0u, nthreads) {
             let loop_ = ~UvEventLoop::new();
             let mut sched = ~Scheduler::new(loop_,
-                                            work_queue.clone(),
+                                            work_queues[i].clone(),
+                                            work_queues.clone(),
                                             sleepers.clone());
             let handle = sched.make_handle();
 
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 2d0a2d98e9f..05a17f8539c 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -98,6 +98,7 @@ use rt::kill::KillHandle;
 use rt::sched::Scheduler;
 use rt::uv::uvio::UvEventLoop;
 use rt::thread::Thread;
+use rt::work_queue::WorkQueue;
 
 #[cfg(test)] use task::default_task_opts;
 #[cfg(test)] use comm;
@@ -722,10 +723,16 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
             let sched = Local::unsafe_borrow::<Scheduler>();
             let sched_handle = (*sched).make_handle();
 
+            // Since this is a 1:1 scheduler we create a queue not in
+            // the stealee set. The run_anything flag is set false
+            // which will disable stealing.
+            let work_queue = WorkQueue::new();
+
             // Create a new scheduler to hold the new task
             let new_loop = ~UvEventLoop::new();
             let mut new_sched = ~Scheduler::new_special(new_loop,
-                                                        (*sched).work_queue.clone(),
+                                                        work_queue,
+                                                        (*sched).work_queues.clone(),
                                                         (*sched).sleeper_list.clone(),
                                                         false,
                                                         Some(sched_handle));
diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs
new file mode 100644
index 00000000000..3d38d61bc2e
--- /dev/null
+++ b/src/test/bench/rt-messaging-ping-pong.rs
@@ -0,0 +1,82 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern mod extra;
+
+use std::task::spawn;
+use std::os;
+use std::uint;
+use std::rt::test::spawntask_later;
+use std::cell::Cell;
+
+// This is a simple bench that creates M pairs of of tasks. These
+// tasks ping-pong back and forth over a pair of streams. This is a
+// cannonical message-passing benchmark as it heavily strains message
+// passing and almost nothing else.
+
+fn ping_pong_bench(n: uint, m: uint) {
+
+    // Create pairs of tasks that pingpong back and forth.
+    fn run_pair(n: uint) {
+            // Create a stream A->B
+            let (pa,ca) = stream::<()>();
+            // Create a stream B->A
+            let (pb,cb) = stream::<()>();
+
+            let pa = Cell::new(pa);
+            let ca = Cell::new(ca);
+            let pb = Cell::new(pb);
+            let cb = Cell::new(cb);
+
+        do spawntask_later() || {
+            let chan = ca.take();
+            let port = pb.take();
+            do n.times {
+                chan.send(());
+                port.recv();
+            }
+        }
+
+        do spawntask_later() || {
+            let chan = cb.take();
+            let port = pa.take();
+            do n.times {
+                port.recv();
+                chan.send(());
+            }
+        }
+    }
+
+    do m.times {
+        run_pair(n)
+    }
+
+}
+
+
+
+fn main() {
+
+    let args = os::args();
+    let n = if args.len() == 3 {
+        uint::from_str(args[1]).unwrap()
+    } else {
+        10000
+    };
+
+    let m = if args.len() == 3 {
+        uint::from_str(args[2]).unwrap()
+    } else {
+        4
+    };
+
+    ping_pong_bench(n, m);
+
+}
diff --git a/src/test/bench/rt-parfib.rs b/src/test/bench/rt-parfib.rs
new file mode 100644
index 00000000000..6669342f511
--- /dev/null
+++ b/src/test/bench/rt-parfib.rs
@@ -0,0 +1,49 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern mod extra;
+
+use std::task::spawn;
+use std::os;
+use std::uint;
+use std::rt::test::spawntask_later;
+use std::cell::Cell;
+use std::comm::*;
+
+// A simple implementation of parfib. One subtree is found in a new
+// task and communicated over a oneshot pipe, the other is found
+// locally. There is no sequential-mode threshold.
+
+fn parfib(n: uint) -> uint {
+    if(n == 0 || n == 1) {
+        return 1;
+    }
+
+    let (port,chan) = oneshot::<uint>();
+    let chan = Cell::new(chan);
+    do spawntask_later {
+        chan.take().send(parfib(n-1));
+    };
+    let m2 = parfib(n-2);
+    return (port.recv() + m2);
+}
+
+fn main() {
+
+    let args = os::args();
+    let n = if args.len() == 2 {
+        uint::from_str(args[1]).unwrap()
+    } else {
+        10
+    };
+
+    parfib(n);
+
+}
diff --git a/src/test/bench/rt-spawn-rate.rs b/src/test/bench/rt-spawn-rate.rs
new file mode 100644
index 00000000000..ff578ed70b9
--- /dev/null
+++ b/src/test/bench/rt-spawn-rate.rs
@@ -0,0 +1,33 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern mod extra;
+
+use std::task::spawn;
+use std::os;
+use std::uint;
+
+// Very simple spawn rate test. Spawn N tasks that do nothing and
+// return.
+
+fn main() {
+
+    let args = os::args();
+    let n = if args.len() == 2 {
+        uint::from_str(args[1]).unwrap()
+    } else {
+        100000
+    };
+
+    do n.times {
+        do spawn || {};
+    }
+
+}
-- 
cgit 1.4.1-3-g733a5