---

yaml
---
r: 212685
b: refs/heads/tmp
c: ebc3de2
h: refs/heads/master
i:
  212683: 3172d6c
v: v3

Author: TheNeikos

[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: c95da07eb080278071079d9f75f45e2042b12f0b
+refs/heads/tmp: ebc3de22d8e3b7b1d6e2c77e444965bb9db51aa7
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: bea1c4a78e5233ea6f85a2028a26e08c26635fca
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/compiletest/runtest.rs

@@ -651,7 +651,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 
     // Write debugger script:
     // We don't want to hang when calling `quit` while the process is still running
-    let mut script_str = String::from("settings set auto-confirm true\n");
+    let mut script_str = String::from_str("settings set auto-confirm true\n");
 
     // Make LLDB emit its version, so we have it documented in the test output
     script_str.push_str("version\n");

branches/tmp/src/doc/reference.md

@@ -1038,7 +1038,7 @@ be undesired.
 
 * Deadlocks
 * Reading data from private fields (`std::repr`)
-* Leaks of memory and other resources
+* Leaks due to reference count cycles, even in the global heap
 * Exiting without calling destructors
 * Sending signals
 * Accessing/modifying the file system

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

@@ -33,8 +33,8 @@ let plus_two = |x| {
 assert_eq!(4, plus_two(2));
 ```
 
-You’ll notice a few things about closures that are a bit different from regular
-functions defined with `fn`. The first is that we did not need to
+You’ll notice a few things about closures that are a bit different than regular
+functions defined with `fn`. The first of which is that we did not need to
 annotate the types of arguments the closure takes or the values it returns. We
 can:
 
@@ -48,18 +48,18 @@ But we don’t have to. Why is this? Basically, it was chosen for ergonomic reas
 While specifying the full type for named functions is helpful with things like
 documentation and type inference, the types of closures are rarely documented
 since they’re anonymous, and they don’t cause the kinds of error-at-a-distance
-problems that inferring named function types can.
+that inferring named function types can.
 
 The second is that the syntax is similar, but a bit different. I’ve added spaces
-here for easier comparison:
+here to make them look a little closer:
 
 ```rust
 fn  plus_one_v1   (x: i32) -> i32 { x + 1 }
 let plus_one_v2 = |x: i32| -> i32 { x + 1 };
 let plus_one_v3 = |x: i32|          x + 1  ;
 ```
 
-Small differences, but they’re similar.
+Small differences, but they’re similar in ways.
 
 # Closures and their environment
 
@@ -99,7 +99,7 @@ note: previous borrow ends here
 fn main() {
     let mut num = 5;
     let plus_num = |x| x + num;
-
+    
     let y = &mut num;
 }
 ^
@@ -161,7 +161,7 @@ of `num`. So what’s the difference?
 ```rust
 let mut num = 5;
 
-{
+{ 
     let mut add_num = |x: i32| num += x;
 
     add_num(5);
@@ -180,7 +180,7 @@ If we change to a `move` closure, it’s different:
 ```rust
 let mut num = 5;
 
-{
+{ 
     let mut add_num = move |x: i32| num += x;
 
     add_num(5);

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

@@ -29,9 +29,6 @@ The other kind of comment is a doc comment. Doc comments use `///` instead of
 /// let five = 5;
 ///
 /// assert_eq!(6, add_one(5));
-/// # fn add_one(x: i32) -> i32 {
-/// #     x + 1
-/// # }
 /// ```
 fn add_one(x: i32) -> i32 {
     x + 1

branches/tmp/src/doc/trpl/dining-philosophers.md

@@ -432,9 +432,7 @@ an extra annotation, `move`, to indicate that the closure is going to take
 ownership of the values it’s capturing. Primarily, the `p` variable of the
 `map` function.
 
-Inside the thread, all we do is call `eat()` on `p`. Also note that the call to `thread::spawn` lacks a trailing semicolon, making this an expression. This distinction is important, yielding the correct return value. For more details, read [Expressions vs. Statements][es].
-
-[es]: functions.html#expressions-vs.-statements
+Inside the thread, all we do is call `eat()` on `p`.
 
 ```rust,ignore
 }).collect();

branches/tmp/src/doc/trpl/error-handling.md

@@ -284,7 +284,7 @@ struct Info {
 }
 
 fn write_info(info: &Info) -> io::Result<()> {
-    let mut file = File::create("my_best_friends.txt").unwrap();
+    let mut file = try!(File::create("my_best_friends.txt"));
 
     try!(writeln!(&mut file, "name: {}", info.name));
     try!(writeln!(&mut file, "age: {}", info.age));

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

@@ -156,46 +156,6 @@ that, just like a move, when we assign `v` to `v2`, a copy of the data is made.
 But, unlike a move, we can still use `v` afterward. This is because an `i32`
 has no pointers to data somewhere else, copying it is a full copy.
 
-All primitive types implement the `Copy` trait and their ownership is
-therefore not moved like one would assume, following the ´ownership rules´.
-To give an example, the two following snippets of code only compile because the 
-`i32` and `bool` types implement the `Copy` trait. 
-
-```rust
-fn main() {
-    let a = 5;
-
-    let _y = double(a);
-    println!("{}", a);
-}
-
-fn double(x: i32) -> i32 {
-    x * 2
-}
-```
-
-```rust
-fn main() {
-    let a = true;
-
-    let _y = change_truth(a);
-    println!("{}", a);
-}
-
-fn change_truth(x: bool) -> bool {
-    !x
-}
-```
-
-If we would have used types that do not implement the `Copy` trait,
-we would have gotten a compile error because we tried to use a moved value.
-
-```text
-error: use of moved value: `a`
-println!("{}", a);
-               ^
-```
-
 We will discuss how to make your own types `Copy` in the [traits][traits]
 section.
 

branches/tmp/src/doc/trpl/trait-objects.md

@@ -261,7 +261,7 @@ static Foo_for_String_vtable: FooVtable = FooVtable {
 ```
 
 The `destructor` field in each vtable points to a function that will clean up
-any resources of the vtable’s type: for `u8` it is trivial, but for `String` it
+any resources of the vtable’s type, for `u8` it is trivial, but for `String` it
 will free the memory. This is necessary for owning trait objects like
 `Box<Foo>`, which need to clean-up both the `Box` allocation as well as the
 internal type when they go out of scope. The `size` and `align` fields store
@@ -270,7 +270,7 @@ essentially unused at the moment since the information is embedded in the
 destructor, but will be used in the future, as trait objects are progressively
 made more flexible.
 
-Suppose we’ve got some values that implement `Foo`. The explicit form of
+Suppose we’ve got some values that implement `Foo`, then the explicit form of
 construction and use of `Foo` trait objects might look a bit like (ignoring the
 type mismatches: they’re all just pointers anyway):
 

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

@@ -45,7 +45,7 @@ but we don’t define a body, just a type signature. When we `impl` a trait,
 we use `impl Trait for Item`, rather than just `impl Item`.
 
 We can use traits to constrain our generics. Consider this function, which
-does not compile:
+does not compile, and gives us a similar error:
 
 ```rust,ignore
 fn print_area<T>(shape: T) {
@@ -56,7 +56,7 @@ fn print_area<T>(shape: T) {
 Rust complains:
 
 ```text
-error: no method named `area` found for type `T` in the current scope
+error: type `T` does not implement any method in scope named `area`
 ```
 
 Because `T` can be any type, we can’t be sure that it implements the `area`
@@ -212,10 +212,10 @@ This will compile without error.
 This means that even if someone does something bad like add methods to `i32`,
 it won’t affect you, unless you `use` that trait.
 
-There’s one more restriction on implementing traits: either the trait, or the
-type you’re writing the `impl` for, must be defined by you. So, we could
+There’s one more restriction on implementing traits. Either the trait or the
+type you’re writing the `impl` for must be defined by you. So, we could
 implement the `HasArea` type for `i32`, because `HasArea` is in our code. But
-if we tried to implement `ToString`, a trait provided by Rust, for `i32`, we could
+if we tried to implement `Float`, a trait provided by Rust, for `i32`, we could
 not, because neither the trait nor the type are in our code.
 
 One last thing about traits: generic functions with a trait bound use

branches/tmp/src/grammar/verify.rs

@@ -287,7 +287,7 @@ fn main() {
     let options = config::basic_options();
     let session = session::build_session(options, None,
                                          syntax::diagnostics::registry::Registry::new(&[]));
-    let filemap = session.parse_sess.codemap().new_filemap(String::from("<n/a>"), code);
+    let filemap = session.parse_sess.codemap().new_filemap(String::from_str("<n/a>"), code);
     let mut lexer = lexer::StringReader::new(session.diagnostic(), filemap);
     let cm = session.codemap();
 

branches/tmp/src/libcollections/binary_heap.rs

@@ -760,10 +760,3 @@ impl<T: Ord> Extend<T> for BinaryHeap<T> {
         }
     }
 }
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BinaryHeap<T> {
-    fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}

branches/tmp/src/libcollections/bit.rs

@@ -1070,13 +1070,6 @@ impl Extend<bool> for BitVec {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a> Extend<&'a bool> for BitVec {
-    fn extend<I: IntoIterator<Item=&'a bool>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Clone for BitVec {
     #[inline]
@@ -1285,13 +1278,6 @@ impl Extend<usize> for BitSet {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a> Extend<&'a usize> for BitSet {
-    fn extend<I: IntoIterator<Item=&'a usize>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl PartialOrd for BitSet {
     #[inline]

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

@@ -879,13 +879,6 @@ impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap<K, V> {
-    fn extend<I: IntoIterator<Item=(&'a K, &'a V)>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().map(|(&key, &value)| (key, value)));
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K: Hash, V: Hash> Hash for BTreeMap<K, V> {
     fn hash<H: Hasher>(&self, state: &mut H) {

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

@@ -509,13 +509,6 @@ impl<T: Ord> Extend<T> for BTreeSet<T> {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BTreeSet<T> {
-    fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Ord> Default for BTreeSet<T> {
     #[stable(feature = "rust1", since = "1.0.0")]

branches/tmp/src/libcollections/enum_set.rs

@@ -288,10 +288,3 @@ impl<E:CLike> Extend<E> for EnumSet<E> {
         }
     }
 }
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, E: 'a + CLike + Copy> Extend<&'a E> for EnumSet<E> {
-    fn extend<I: IntoIterator<Item=&'a E>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}

branches/tmp/src/libcollections/linked_list.rs

@@ -904,13 +904,6 @@ impl<A> Extend<A> for LinkedList<A> {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy> Extend<&'a T> for LinkedList<T> {
-    fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A: PartialEq> PartialEq for LinkedList<A> {
     fn eq(&self, other: &LinkedList<A>) -> bool {

branches/tmp/src/libcollections/string.rs

@@ -89,12 +89,12 @@ impl String {
     ///
     /// ```
     /// # #![feature(collections)]
-    /// let s = String::from("hello");
+    /// let s = String::from_str("hello");
     /// assert_eq!(&s[..], "hello");
     /// ```
     #[inline]
-    #[unstable(feature = "collections", reason = "use `String::from` instead")]
-    #[deprecated(since = "1.2.0", reason = "use `String::from` instead")]
+    #[unstable(feature = "collections",
+               reason = "needs investigation to see if to_string() can match perf")]
     #[cfg(not(test))]
     pub fn from_str(string: &str) -> String {
         String { vec: <[_]>::to_vec(string.as_bytes()) }
@@ -793,13 +793,6 @@ impl Extend<char> for String {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a> Extend<&'a char> for String {
-    fn extend<I: IntoIterator<Item=&'a char>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Extend<&'a str> for String {
     fn extend<I: IntoIterator<Item=&'a str>>(&mut self, iterable: I) {
@@ -1009,7 +1002,7 @@ pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
     DerefString { x: as_vec(x.as_bytes()) }
 }
 
-/// Error returned from `String::from`
+/// Error returned from `String::from_str`
 #[unstable(feature = "str_parse_error", reason = "may want to be replaced with \
                                                   Void if it ever exists")]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -1020,7 +1013,7 @@ impl FromStr for String {
     type Err = ParseError;
     #[inline]
     fn from_str(s: &str) -> Result<String, ParseError> {
-        Ok(String::from(s))
+        Ok(String::from_str(s))
     }
 }
 

branches/tmp/src/libcollections/vec.rs

@@ -1578,13 +1578,6 @@ impl<T> Extend<T> for Vec<T> {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy> Extend<&'a T> for Vec<T> {
-    fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 __impl_slice_eq1! { Vec<A>, Vec<B> }
 __impl_slice_eq1! { Vec<A>, &'b [B] }
 __impl_slice_eq1! { Vec<A>, &'b mut [B] }

branches/tmp/src/libcollections/vec_deque.rs

@@ -1785,13 +1785,6 @@ impl<A> Extend<A> for VecDeque<A> {
     }
 }
 
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> {
-    fn extend<I: IntoIterator<Item=&'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: fmt::Debug> fmt::Debug for VecDeque<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {