---

yaml
---
r: 208279
b: refs/heads/snap-stage3
c: 685f557
h: refs/heads/master
i:
  208277: c39995d
  208275: 32d8cae
  208271: 5512ab5
v: v3

Author: frewsxcv

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8004fc9fe0591f9537c0f6e993234eb86989c538
+refs/heads/snap-stage3: 685f557729e3bb2691a81ac10074bddf4f61a0b6
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/doc/trpl/guessing-game.md

@@ -713,7 +713,7 @@ variety of numbers, we need to give Rust a hint as to the exact type of number
 we want. Hence, `let guess: u32`. The colon (`:`) after `guess` tells Rust
 we’re going to annotate its type. `u32` is an unsigned, thirty-two bit
 integer. Rust has [a number of built-in number types][number], but we’ve
-chosen `u32`. It’s a good default choice for a small positive number.
+chosen `u32`. It’s a good default choice for a small positive numer.
 
 [parse]: ../std/primitive.str.html#method.parse
 [number]: primitive-types.html#numeric-types
@@ -922,7 +922,7 @@ failure. Each contains more information: the successful parsed integer, or an
 error type. In this case, we `match` on `Ok(num)`, which sets the inner value
 of the `Ok` to the name `num`, and then we just return it on the right-hand
 side. In the `Err` case, we don’t care what kind of error it is, so we just
-use `_` instead of a name. This ignores the error, and `continue` causes us
+use `_` intead of a name. This ignores the error, and `continue` causes us
 to go to the next iteration of the `loop`.
 
 Now we should be good! Let’s try:

branches/snap-stage3/src/doc/trpl/match.md

@@ -50,7 +50,7 @@ side of a `let` binding or directly where an expression is used:
 ```rust
 let x = 5;
 
-let number = match x {
+let numer = match x {
     1 => "one",
     2 => "two",
     3 => "three",

branches/snap-stage3/src/doc/trpl/mutability.md

@@ -78,8 +78,8 @@ When we call `clone()`, the `Arc<T>` needs to update the reference count. Yet
 we’ve not used any `mut`s here, `x` is an immutable binding, and we didn’t take
 `&mut 5` or anything. So what gives?
 
-To understand this, we have to go back to the core of Rust’s guiding
-philosophy, memory safety, and the mechanism by which Rust guarantees it, the
+To this, we have to go back to the core of Rust’s guiding philosophy, memory
+safety, and the mechanism by which Rust guarantees it, the
 [ownership][ownership] system, and more specifically, [borrowing][borrowing]:
 
 > You may have one or the other of these two kinds of borrows, but not both at
@@ -169,7 +169,7 @@ struct Point {
     y: Cell<i32>,
 }
 
-let point = Point { x: 5, y: Cell::new(6) };
+let mut point = Point { x: 5, y: Cell::new(6) };
 
 point.y.set(7);
 

branches/snap-stage3/src/doc/trpl/ownership.md

@@ -174,7 +174,7 @@ fn foo(v: Vec<i32>) -> Vec<i32> {
 }
 ```
 
-This would get very tedious. It gets worse the more things we want to take ownership of:
+This would get very tedius. It gets worse the more things we want to take ownership of:
 
 ```rust
 fn foo(v1: Vec<i32>, v2: Vec<i32>) -> (Vec<i32>, Vec<i32>, i32) {

branches/snap-stage3/src/doc/trpl/primitive-types.md

@@ -176,7 +176,7 @@ Slices have type `&[T]`. We’ll talk about that `T` when we cover
 
 [generics]: generics.html
 
-You can find more documentation for slices [in the standard library
+You can find more documentation for `slices`s [in the standard library
 documentation][slice].
 
 [slice]: ../std/primitive.slice.html

branches/snap-stage3/src/doc/trpl/references-and-borrowing.md

@@ -312,7 +312,6 @@ println!("{}", y);
 
 We get this error:
 
-```text
 error: `x` does not live long enough
     y = &x;
          ^
@@ -335,37 +334,3 @@ In other words, `y` is only valid for the scope where `x` exists. As soon as
 `x` goes away, it becomes invalid to refer to it. As such, the error says that
 the borrow ‘doesn’t live long enough’ because it’s not valid for the right
 amount of time.
-
-The same problem occurs when the reference is declared _before_ the variable it refers to:
-
-```rust,ignore
-let y: &i32;
-let x = 5;
-y = &x;
-
-println!("{}", y);
-```
-
-We get this error:
-
-```text
-error: `x` does not live long enough
-y = &x;
-     ^
-note: reference must be valid for the block suffix following statement 0 at
-2:16...
-    let y: &i32;
-    let x = 5;
-    y = &x;
-    
-    println!("{}", y);
-}
-
-note: ...but borrowed value is only valid for the block suffix following
-statement 1 at 3:14
-    let x = 5;
-    y = &x;
-    
-    println!("{}", y);
-}
-```

branches/snap-stage3/src/etc/CONFIGS.md

@@ -1,16 +1,10 @@
 # Configs
 
-These are some links to repos with configs which ease the use of rust.
-
-## Officially Maintained Configs
+Here are some links to repos with configs which ease the use of rust:
 
 * [rust.vim](https://github.com/rust-lang/rust.vim)
 * [emacs rust-mode](https://github.com/rust-lang/rust-mode)
 * [gedit-config](https://github.com/rust-lang/gedit-config)
 * [kate-config](https://github.com/rust-lang/kate-config)
 * [nano-config](https://github.com/rust-lang/nano-config)
 * [zsh-config](https://github.com/rust-lang/zsh-config)
-
-## Community-maintained Configs
-
-* [.editorconfig](https://gist.github.com/derhuerst/c9d1b9309e308d9851fa) ([what is this?](http://editorconfig.org/))

branches/snap-stage3/src/etc/check-sanitycheck.py

@@ -13,6 +13,7 @@
 import os
 import sys
 import functools
+import resource
 
 STATUS = 0
 
@@ -36,7 +37,6 @@ def inner():
 
 @only_on(('linux', 'darwin', 'freebsd', 'openbsd'))
 def check_rlimit_core():
-    import resource
     soft, hard = resource.getrlimit(resource.RLIMIT_CORE)
     if soft > 0:
         error_unless_permitted('ALLOW_NONZERO_RLIMIT_CORE', """\

branches/snap-stage3/src/libcollections/bit.rs

@@ -1796,89 +1796,6 @@ impl BitSet {
         self.other_op(other, |w1, w2| w1 ^ w2);
     }
 
-    /// Moves all elements from `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_set_append_split_off)]
-    /// use std::collections::{BitVec, BitSet};
-    ///
-    /// let mut a = BitSet::new();
-    /// a.insert(2);
-    /// a.insert(6);
-    ///
-    /// let mut b = BitSet::new();
-    /// b.insert(1);
-    /// b.insert(3);
-    /// b.insert(6);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.len(), 4);
-    /// assert_eq!(b.len(), 0);
-    /// assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b01110010])));
-    /// ```
-    #[unstable(feature = "bit_set_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn append(&mut self, other: &mut Self) {
-        self.union_with(other);
-        other.clear();
-    }
-
-    /// Splits the `BitSet` into two at the given key including the key.
-    /// Retains the first part in-place while returning the second part.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_set_append_split_off)]
-    /// use std::collections::{BitSet, BitVec};
-    /// let mut a = BitSet::new();
-    /// a.insert(2);
-    /// a.insert(6);
-    /// a.insert(1);
-    /// a.insert(3);
-    ///
-    /// let b = a.split_off(3);
-    ///
-    /// assert_eq!(a.len(), 2);
-    /// assert_eq!(b.len(), 2);
-    /// assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b01100000])));
-    /// assert_eq!(b, BitSet::from_bit_vec(BitVec::from_bytes(&[0b00010010])));
-    /// ```
-    #[unstable(feature = "bit_set_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        let mut other = BitSet::new();
-
-        if at == 0 {
-            swap(self, &mut other);
-            return other;
-        } else if at >= self.bit_vec.len() {
-            return other;
-        }
-
-        // Calculate block and bit at which to split
-        let w = at / u32::BITS;
-        let b = at % u32::BITS;
-
-        // Pad `other` with `w` zero blocks,
-        // append `self`'s blocks in the range from `w` to the end to `other`
-        other.bit_vec.storage.extend(repeat(0u32).take(w)
-                                     .chain(self.bit_vec.storage[w..].iter().cloned()));
-        other.bit_vec.nbits = self.bit_vec.nbits;
-
-        if b > 0 {
-            other.bit_vec.storage[w] &= !0 << b;
-        }
-
-        // Sets `bit_vec.len()` and fixes the last block as well
-        self.bit_vec.truncate(at);
-
-        other
-    }
-
     /// Returns the number of set bits in this set.
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]

branches/snap-stage3/src/libcollections/string.rs

@@ -1052,7 +1052,6 @@ impl<T: fmt::Display + ?Sized> ToString for T {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl AsRef<str> for String {
-    #[inline]
     fn as_ref(&self) -> &str {
         self
     }

branches/snap-stage3/src/libcollectionstest/bit/set.rs

@@ -387,67 +387,6 @@ fn test_bit_vec_clone() {
     assert!(b.contains(&1000));
 }
 
-#[test]
-fn test_bit_set_append() {
-    let mut a = BitSet::new();
-    a.insert(2);
-    a.insert(6);
-
-    let mut b = BitSet::new();
-    b.insert(1);
-    b.insert(3);
-    b.insert(6);
-
-    a.append(&mut b);
-
-    assert_eq!(a.len(), 4);
-    assert_eq!(b.len(), 0);
-    assert!(b.capacity() >= 6);
-
-    assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b01110010])));
-}
-
-#[test]
-fn test_bit_set_split_off() {
-    // Split at 0
-    let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100000, 0b00010010, 0b10010010,
-                                                          0b00110011, 0b01101011, 0b10101101]));
-
-    let b = a.split_off(0);
-
-    assert_eq!(a.len(), 0);
-    assert_eq!(b.len(), 21);
-
-    assert_eq!(b, BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100000, 0b00010010, 0b10010010,
-                                                            0b00110011, 0b01101011, 0b10101101])));
-
-    // Split behind last element
-    let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100000, 0b00010010, 0b10010010,
-                                                          0b00110011, 0b01101011, 0b10101101]));
-
-    let b = a.split_off(50);
-
-    assert_eq!(a.len(), 21);
-    assert_eq!(b.len(), 0);
-
-    assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100000, 0b00010010, 0b10010010,
-                                                            0b00110011, 0b01101011, 0b10101101])));
-
-    // Split at arbitrary element
-    let mut a = BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100000, 0b00010010, 0b10010010,
-                                                          0b00110011, 0b01101011, 0b10101101]));
-
-    let b = a.split_off(34);
-
-    assert_eq!(a.len(), 12);
-    assert_eq!(b.len(), 9);
-
-    assert_eq!(a, BitSet::from_bit_vec(BitVec::from_bytes(&[0b10100000, 0b00010010, 0b10010010,
-                                                            0b00110011, 0b01000000])));
-    assert_eq!(b, BitSet::from_bit_vec(BitVec::from_bytes(&[0, 0, 0, 0,
-                                                            0b00101011, 0b10101101])));
-}
-
 mod bench {
     use std::collections::{BitSet, BitVec};
     use std::__rand::{Rng, thread_rng, ThreadRng};

branches/snap-stage3/src/libcollectionstest/lib.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(bit_set_append_split_off)]
 #![feature(bit_vec_append_split_off)]
 #![feature(box_syntax)]
 #![feature(collections)]

branches/snap-stage3/src/libcore/convert.rs

@@ -173,7 +173,6 @@ impl<T> AsMut<[T]> for [T] {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl AsRef<str> for str {
-    #[inline]
     fn as_ref(&self) -> &str {
         self
     }