---

yaml
---
r: 208287
b: refs/heads/snap-stage3
c: 4e8afd6
h: refs/heads/master
i:
  208285: e3fb003
  208283: 58461f6
  208279: 0f34ad9
  208271: 5512ab5
  208255: c00e252
v: v3

Author: Ulrik Sverdrup

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8f01d8d7c290f24980e2915b2df14d244eb430a2
+refs/heads/snap-stage3: 4e8afd65f93f1c351365c71f4461a2c6728f8287
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/doc/reference.md

@@ -842,7 +842,7 @@ module declarations should be at the crate root if direct usage of the declared
 modules within `use` items is desired. It is also possible to use `self` and
 `super` at the beginning of a `use` item to refer to the current and direct
 parent modules respectively. All rules regarding accessing declared modules in
-`use` declarations apply to both module declarations and `extern crate`
+`use` declarations applies to both module declarations and `extern crate`
 declarations.
 
 An example of what will and will not work for `use` items:
@@ -2564,19 +2564,12 @@ array is mutable, the resulting [lvalue](#lvalues,-rvalues-and-temporaries) can
 be assigned to.
 
 Indices are zero-based, and may be of any integral type. Vector access is
-bounds-checked at compile-time for constant arrays being accessed with a constant index value.
-Otherwise a check will be performed at run-time that will put the thread in a _panicked state_ if it fails.
+bounds-checked at run-time. When the check fails, it will put the thread in a
+_panicked state_.
 
 ```{should-fail}
 ([1, 2, 3, 4])[0];
-
-let x = (["a", "b"])[10]; // compiler error: const index-expr is out of bounds
-
-let n = 10;
-let y = (["a", "b"])[n]; // panics
-
-let arr = ["a", "b"];
-arr[10]; // panics
+(["a", "b"])[10]; // panics
 ```
 
 ### Range expressions

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

@@ -273,7 +273,7 @@ information’. Why throw it away? Well, for a basic program, we just want to
 print a generic error, as basically any issue means we can’t continue. The
 [`ok()` method][ok] returns a value which has another method defined on it:
 `expect()`. The [`expect()` method][expect] takes a value it’s called on, and
-if it isn’t a successful one, [`panic!`][panic]s with a message you
+if it isn’t a successful one, [`panic!`][panic]s with a message you passed you
 passed it. A `panic!` like this will cause our program to crash, displaying
 the message.
 

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

@@ -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/references-and-borrowing.md

@@ -6,7 +6,7 @@ become quite acquainted. Ownership is how Rust achieves its largest goal,
 memory safety. There are a few distinct concepts, each with its own
 chapter:
 
-* [ownership][ownership], the key concept
+* [ownership][ownership], ownership, the key concept
 * borrowing, which you’re reading now
 * [lifetimes][lifetimes], an advanced concept of borrowing
 
@@ -368,4 +368,4 @@ statement 1 at 3:14
     
     println!("{}", y);
 }
-```
+```

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/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)]