---

yaml
---
r: 210559
b: refs/heads/try
c: c4b72a8
h: refs/heads/master
i:
  210557: 121a125
  210555: d7c4f5c
  210551: 031ff77
  210543: 3111baa
  210527: 08dcf65
  210495: cfeea2a
  210431: 1062752
v: v3

Author: richo

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: 73345185793cca8a0b4c77aa87973a2634a0c492
+refs/heads/try: c4b72a88ef2e6f79bfbab0fc2784eb1c3c366487
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/reference.md

@@ -2028,7 +2028,7 @@ makes it possible to declare these operations. For example, the `str` module
 in the Rust standard library defines the string equality function:
 
 ```{.ignore}
-#[lang = "str_eq"]
+#[lang="str_eq"]
 pub fn eq_slice(a: &str, b: &str) -> bool {
     // details elided
 }

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

@@ -214,7 +214,7 @@ we can use the `unwrap()` method:
 io::stdin().read_line(&mut buffer).unwrap();
 ```
 
-`unwrap()` will `panic!` if the `Result` is `Err`. This basically says "Give
+`unwrap()` will `panic!` if the `Option` is `None`. This basically says "Give
 me the value, and if something goes wrong, just crash." This is less reliable
 than matching the error and attempting to recover, but is also significantly
 shorter. Sometimes, just crashing is appropriate.

branches/try/src/doc/trpl/guessing-game.md

@@ -131,9 +131,7 @@ prints a [string][strings] to the screen.
     let mut guess = String::new();
 ```
 
-Now we’re getting interesting! There’s a lot going on in this little line.
-The first thing to notice is that this is a [let statement][let], which is
-used to create ‘variable bindings’. They take this form:
+Now we’re getting interesting! There’s a lot going on in this little line. The first thing to notice is that this is a [let statement][let], which is used to create ‘variable bindings’. They take this form:
 
 ```rust,ignore
 let foo = bar;
@@ -173,7 +171,7 @@ bound to: `String::new()`.
 
 [string]: ../std/string/struct.String.html
 
-The `::new()` syntax uses `::` because this is an ‘associated function’ of
+The `::new()` syntax is uses `::` because this is an ‘associated function’ of
 a particular type. That is to say, it’s associated with `String` itself,
 rather than a particular instance of a `String`. Some languages call this a
 ‘static method’.
@@ -713,7 +711,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 +920,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/try/src/doc/trpl/lang-items.md

@@ -7,7 +7,7 @@
 The `rustc` compiler has certain pluggable operations, that is,
 functionality that isn't hard-coded into the language, but is
 implemented in libraries, with a special marker to tell the compiler
-it exists. The marker is the attribute `#[lang = "..."]` and there are
+it exists. The marker is the attribute `#[lang="..."]` and there are
 various different values of `...`, i.e. various different 'lang
 items'.
 
@@ -28,7 +28,7 @@ extern {
 #[lang = "owned_box"]
 pub struct Box<T>(*mut T);
 
-#[lang = "exchange_malloc"]
+#[lang="exchange_malloc"]
 unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
     let p = libc::malloc(size as libc::size_t) as *mut u8;
 
@@ -39,7 +39,7 @@ unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
 
     p
 }
-#[lang = "exchange_free"]
+#[lang="exchange_free"]
 unsafe fn deallocate(ptr: *mut u8, _size: usize, _align: usize) {
     libc::free(ptr as *mut libc::c_void)
 }

branches/try/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/try/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

branches/try/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/try/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/try/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/try/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/try/src/etc/check-sanitycheck.py

@@ -13,7 +13,6 @@
 import os
 import sys
 import functools
-import resource
 
 STATUS = 0
 
@@ -37,6 +36,7 @@ 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/try/src/liballoc/heap.rs

@@ -95,7 +95,7 @@ pub const EMPTY: *mut () = 0x1 as *mut ();
 
 /// The allocator for unique pointers.
 #[cfg(not(test))]
-#[lang = "exchange_malloc"]
+#[lang="exchange_malloc"]
 #[inline]
 unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
     if size == 0 {
@@ -108,7 +108,7 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
 }
 
 #[cfg(not(test))]
-#[lang = "exchange_free"]
+#[lang="exchange_free"]
 #[inline]
 unsafe fn exchange_free(ptr: *mut u8, old_size: usize, align: usize) {
     deallocate(ptr, old_size, align);

branches/try/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/try/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/try/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};