---

yaml
---
r: 212807
b: refs/heads/tmp
c: 91effb3
h: refs/heads/master
i:
  212805: 1aa1f01
  212803: 492ede0
  212799: 8ec98cf
v: v3

Author: swgillespie

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 4efc4ec178f6ddf3c8cd268b011f3a04056f9d16
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: b5b3a99f84f2b4dbf9495dccd7112c74f4357acc
+refs/heads/tmp: 91effb374c98927823b3032f7433e7b73a229f95
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: bea1c4a78e5233ea6f85a2028a26e08c26635fca
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/compiletest/runtest.rs

@@ -285,8 +285,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
                             format!("--target={}", config.target),
                             "-L".to_string(),
                             aux_dir.to_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags));
-        args.extend(split_maybe_args(&props.compile_flags));
+        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
+        args.extend(split_maybe_args(&props.compile_flags).into_iter());
         return ProcArgs {
             prog: config.rustc_path.to_str().unwrap().to_string(),
             args: args,
@@ -333,8 +333,8 @@ actual:\n\
                             config.build_base.to_str().unwrap().to_string(),
                             "-L".to_string(),
                             aux_dir.to_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags));
-        args.extend(split_maybe_args(&props.compile_flags));
+        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
+        args.extend(split_maybe_args(&props.compile_flags).into_iter());
         // FIXME (#9639): This needs to handle non-utf8 paths
         return ProcArgs {
             prog: config.rustc_path.to_str().unwrap().to_string(),
@@ -380,7 +380,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             script_str.push_str(&format!("set solib-search-path \
                                          ./{}/stage2/lib/rustlib/{}/lib/\n",
                                          config.host, config.target));
-            for line in &breakpoint_lines {
+            for line in breakpoint_lines.iter() {
                 script_str.push_str(&format!("break {:?}:{}\n",
                                              testfile.file_name().unwrap()
                                                      .to_string_lossy(),
@@ -1171,7 +1171,7 @@ fn document(config: &Config, props: &TestProps,
                         out_dir.to_str().unwrap().to_string(),
                         testfile.to_str().unwrap().to_string()];
     args.extend(extra_args.iter().cloned());
-    args.extend(split_maybe_args(&props.compile_flags));
+    args.extend(split_maybe_args(&props.compile_flags).into_iter());
     let args = ProcArgs {
         prog: config.rustdoc_path.to_str().unwrap().to_string(),
         args: args,
@@ -1236,7 +1236,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
                 vec!("--crate-type=dylib".to_string())
             }
         };
-        crate_type.extend(extra_link_args.clone());
+        crate_type.extend(extra_link_args.clone().into_iter());
         let aux_args =
             make_compile_args(config,
                               &aux_props,
@@ -1334,11 +1334,11 @@ fn make_compile_args<F>(config: &Config,
     };
     args.push(path.to_str().unwrap().to_string());
     if props.force_host {
-        args.extend(split_maybe_args(&config.host_rustcflags));
+        args.extend(split_maybe_args(&config.host_rustcflags).into_iter());
     } else {
-        args.extend(split_maybe_args(&config.target_rustcflags));
+        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
     }
-    args.extend(split_maybe_args(&props.compile_flags));
+    args.extend(split_maybe_args(&props.compile_flags).into_iter());
     return ProcArgs {
         prog: config.rustc_path.to_str().unwrap().to_string(),
         args: args,
@@ -1373,7 +1373,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path)
     args.push(exe_file.to_str().unwrap().to_string());
 
     // Add the arguments in the run_flags directive
-    args.extend(split_maybe_args(&props.run_flags));
+    args.extend(split_maybe_args(&props.run_flags).into_iter());
 
     let prog = args.remove(0);
     return ProcArgs {
@@ -1683,7 +1683,7 @@ fn compile_test_and_save_ir(config: &Config, props: &TestProps,
                              aux_dir.to_str().unwrap().to_string());
     let llvm_args = vec!("--emit=llvm-ir".to_string(),
                          "--crate-type=lib".to_string());
-    link_args.extend(llvm_args);
+    link_args.extend(llvm_args.into_iter());
     let args = make_compile_args(config,
                                  props,
                                  link_args,

branches/tmp/src/doc/complement-lang-faq.md

@@ -30,13 +30,15 @@ You may also be interested in browsing [trending Rust repositories][github-rust]
 
 ## Is anyone using Rust in production?
 
-Yes. For example (incomplete):
+Currently, Rust is still pre-1.0, and so we don't recommend that you use Rust
+in production unless you know exactly what you're getting into.
+
+That said, there are two production deployments of Rust that we're aware of:
 
 * [OpenDNS](http://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/)
 * [Skylight](http://skylight.io)
-* [wit.ai](https://github.com/wit-ai/witd)
-* [Codius](https://codius.org/blog/codius-rust/)
-* [MaidSafe](http://maidsafe.net/)
+
+Let the fact that this is an easily countable number be a warning.
 
 ## Does it run on Windows?
 

branches/tmp/src/doc/reference.md

@@ -1550,7 +1550,7 @@ methods in such an implementation can only be used as direct calls on the
 values of the type that the implementation targets. In such an implementation,
 the trait type and `for` after `impl` are omitted. Such implementations are
 limited to nominal types (enums, structs), and the implementation must appear
-in the same crate as the `self` type:
+in the same module or a sub-module as the `self` type:
 
 ```
 struct Point {x: i32, y: i32}

branches/tmp/src/doc/trpl/closures.md

@@ -324,34 +324,37 @@ first, it may seem strange, but we’ll figure it out. Here’s how you’d prob
 try to return a closure from a function:
 
 ```rust,ignore
-fn factory() -> (Fn(i32) -> i32) {
-    let num = 5;
+fn factory() -> (Fn(i32) -> Vec<i32>) {
+    let vec = vec![1, 2, 3];
 
-    |x| x + num
+    |n| vec.push(n)
 }
 
 let f = factory();
 
-let answer = f(1);
-assert_eq!(6, answer);
+let answer = f(4);
+assert_eq!(vec![1, 2, 3, 4], answer);
 ```
 
 This gives us these long, related errors:
 
 ```text
 error: the trait `core::marker::Sized` is not implemented for the type
-`core::ops::Fn(i32) -> i32` [E0277]
-fn factory() -> (Fn(i32) -> i32) {
-                ^~~~~~~~~~~~~~~~
-note: `core::ops::Fn(i32) -> i32` does not have a constant size known at compile-time
-fn factory() -> (Fn(i32) -> i32) {
-                ^~~~~~~~~~~~~~~~
-error: the trait `core::marker::Sized` is not implemented for the type `core::ops::Fn(i32) -> i32` [E0277]
-let f = factory();
-    ^
-note: `core::ops::Fn(i32) -> i32` does not have a constant size known at compile-time
-let f = factory();
-    ^
+`core::ops::Fn(i32) -> collections::vec::Vec<i32>` [E0277]
+f = factory();
+^
+note: `core::ops::Fn(i32) -> collections::vec::Vec<i32>` does not have a
+constant size known at compile-time
+f = factory();
+^
+error: the trait `core::marker::Sized` is not implemented for the type
+`core::ops::Fn(i32) -> collections::vec::Vec<i32>` [E0277]
+factory() -> (Fn(i32) -> Vec<i32>) {
+             ^~~~~~~~~~~~~~~~~~~~~
+note: `core::ops::Fn(i32) -> collections::vec::Vec<i32>` does not have a constant size known at compile-time
+factory() -> (Fn(i32) -> Vec<i32>) {
+             ^~~~~~~~~~~~~~~~~~~~~
+
 ```
 
 In order to return something from a function, Rust needs to know what
@@ -361,16 +364,16 @@ way to give something a size is to take a reference to it, as references
 have a known size. So we’d write this:
 
 ```rust,ignore
-fn factory() -> &(Fn(i32) -> i32) {
-    let num = 5;
+fn factory() -> &(Fn(i32) -> Vec<i32>) {
+    let vec = vec![1, 2, 3];
 
-    |x| x + num
+    |n| vec.push(n)
 }
 
 let f = factory();
 
-let answer = f(1);
-assert_eq!(6, answer);
+let answer = f(4);
+assert_eq!(vec![1, 2, 3, 4], answer);
 ```
 
 But we get another error:
@@ -445,8 +448,7 @@ assert_eq!(6, answer);
 We use a trait object, by `Box`ing up the `Fn`. There’s just one last problem:
 
 ```text
-error: closure may outlive the current function, but it borrows `num`,
-which is owned by the current function [E0373]
+error: `num` does not live long enough
 Box::new(|x| x + num)
          ^~~~~~~~~~~
 ```

branches/tmp/src/error-index-generator/main.rs

@@ -73,7 +73,7 @@ r##"<!DOCTYPE html>
 
     try!(write!(&mut output_file, "<h1>Rust Compiler Error Index</h1>\n"));
 
-    for (err_code, info) in err_map {
+    for (err_code, info) in err_map.iter() {
         // Enclose each error in a div so they can be shown/hidden en masse.
         let desc_desc = match info.description {
             Some(_) => "error-described",

branches/tmp/src/libarena/lib.rs

@@ -127,7 +127,7 @@ impl<'longer_than_self> Drop for Arena<'longer_than_self> {
     fn drop(&mut self) {
         unsafe {
             destroy_chunk(&*self.head.borrow());
-            for chunk in self.chunks.borrow().iter() {
+            for chunk in &*self.chunks.borrow() {
                 if !chunk.is_copy.get() {
                     destroy_chunk(chunk);
                 }

branches/tmp/src/libcollections/binary_heap.rs

@@ -85,7 +85,7 @@
 //!
 //!         // For each node we can reach, see if we can find a way with
 //!         // a lower cost going through this node
-//!         for edge in &adj_list[position] {
+//!         for edge in adj_list[position].iter() {
 //!             let next = State { cost: cost + edge.cost, position: edge.node };
 //!
 //!             // If so, add it to the frontier and continue
@@ -450,7 +450,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// let vec = heap.into_vec();
     ///
     /// // Will print in some order
-    /// for x in vec {
+    /// for x in vec.iter() {
     ///     println!("{}", x);
     /// }
     /// ```

branches/tmp/src/libcollections/bit.rs

@@ -266,9 +266,9 @@ impl BitVec {
     /// # #![feature(collections)]
     /// use std::collections::BitVec;
     ///
-    /// let bv = BitVec::from_elem(10, false);
+    /// let mut bv = BitVec::from_elem(10, false);
     /// assert_eq!(bv.len(), 10);
-    /// for x in &bv {
+    /// for x in bv.iter() {
     ///     assert_eq!(x, false);
     /// }
     /// ```
@@ -1245,7 +1245,7 @@ impl<'a> IntoIterator for &'a BitVec {
 /// s.union_with(&other);
 ///
 /// // Print 0, 1, 3 in some order
-/// for x in &s {
+/// for x in s.iter() {
 ///     println!("{}", x);
 /// }
 ///
@@ -1370,7 +1370,7 @@ impl BitSet {
     /// let s = BitSet::from_bit_vec(bv);
     ///
     /// // Print 1, 2 in arbitrary order
-    /// for x in &s {
+    /// for x in s.iter() {
     ///     println!("{}", x);
     /// }
     /// ```

branches/tmp/src/libcollections/borrow.rs

@@ -21,7 +21,7 @@ use core::ops::Deref;
 use core::option::Option;
 
 use fmt;
-use alloc::{boxed, rc, arc};
+use alloc::{rc, arc};
 
 use self::Cow::*;
 
@@ -116,14 +116,6 @@ impl<'a, T: ?Sized> BorrowMut<T> for &'a mut T {
     fn borrow_mut(&mut self) -> &mut T { &mut **self }
 }
 
-impl<T: ?Sized> Borrow<T> for boxed::Box<T> {
-    fn borrow(&self) -> &T { &**self }
-}
-
-impl<T: ?Sized> BorrowMut<T> for boxed::Box<T> {
-    fn borrow_mut(&mut self) -> &mut T { &mut **self }
-}
-
 impl<T: ?Sized> Borrow<T> for rc::Rc<T> {
     fn borrow(&self) -> &T { &**self }
 }

branches/tmp/src/libcollections/btree/map.rs

@@ -907,7 +907,7 @@ impl<K: Ord, V> Default for BTreeMap<K, V> {
 impl<K: PartialEq, V: PartialEq> PartialEq for BTreeMap<K, V> {
     fn eq(&self, other: &BTreeMap<K, V>) -> bool {
         self.len() == other.len() &&
-            self.iter().zip(other).all(|(a, b)| a == b)
+            self.iter().zip(other.iter()).all(|(a, b)| a == b)
     }
 }
 
@@ -1544,7 +1544,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// for (_, balance) in map.range_mut(Included(&"B"), Excluded(&"Cheryl")) {
     ///     *balance += 100;
     /// }
-    /// for (name, balance) in &map {
+    /// for (name, balance) in map.iter() {
     ///     println!("{} => {}", name, balance);
     /// }
     /// ```

branches/tmp/src/libcollections/linked_list.rs

@@ -265,7 +265,7 @@ impl<T> LinkedList<T> {
     ///
     /// a.append(&mut b);
     ///
-    /// for e in &a {
+    /// for e in a.iter() {
     ///     println!("{}", e); // prints 1, then 2, then 3, then 4
     /// }
     /// println!("{}", b.len()); // prints 0
@@ -1189,7 +1189,7 @@ mod tests {
         check_links(&m);
 
         let mut i = 0;
-        for (a, &b) in m.into_iter().zip(&v) {
+        for (a, &b) in m.into_iter().zip(v.iter()) {
             i += 1;
             assert_eq!(a, b);
         }

branches/tmp/src/libcollections/slice.rs

@@ -971,7 +971,7 @@ impl<T> [T] {
                reason = "uncertain about this API approach")]
     #[inline]
     pub fn move_from(&mut self, mut src: Vec<T>, start: usize, end: usize) -> usize {
-        for (a, b) in self.iter_mut().zip(&mut src[start .. end]) {
+        for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) {
             mem::swap(a, b);
         }
         cmp::min(self.len(), end-start)