---

yaml
---
r: 210387
b: refs/heads/try
c: 81b90bd
h: refs/heads/master
i:
  210385: 084fa19
  210383: 7c3c0bb
v: v3

Author: banks

[refs]

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

branches/try/src/doc/complement-design-faq.md

@@ -39,7 +39,7 @@ representation as a primitive. This allows using Rust `enum`s in FFI where C
 `enum`s are also used, for most use cases. The attribute can also be applied
 to `struct`s to get the same layout as a C struct would.
 
-[repr]: reference.html#ffi-attributes
+[repr]: reference.html#miscellaneous-attributes
 
 ## There is no GC
 

branches/try/src/doc/reference.md

@@ -1867,12 +1867,13 @@ macro scope.
   lower to the target's SIMD instructions, if any; the `simd` feature gate
   is necessary to use this attribute.
 - `static_assert` - on statics whose type is `bool`, terminates compilation
-  with an error if it is not initialized to `true`. To use this, the `static_assert`
-  feature gate must be enabled.
+  with an error if it is not initialized to `true`.
+- `unsafe_destructor` - allow implementations of the "drop" language item
+  where the type it is implemented for does not implement the "send" language
+  item; the `unsafe_destructor` feature gate is needed to use this attribute
 - `unsafe_no_drop_flag` - on structs, remove the flag that prevents
   destructors from being run twice. Destructors might be run multiple times on
-  the same object with this attribute. To use this, the `unsafe_no_drop_flag` feature
-  gate must be enabled.
+  the same object with this attribute.
 - `doc` - Doc comments such as `/// foo` are equivalent to `#[doc = "foo"]`.
 - `rustc_on_unimplemented` - Write a custom note to be shown along with the error
    when the trait is found to be unimplemented on a type.

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

@@ -86,7 +86,7 @@ fn main() {
         .ok()
         .expect("Failed to read line");
 
-    println!("You guessed: {}", input);
+    println!("You guessed: {}", guess);
 }
 ```
 
@@ -302,12 +302,12 @@ project.
 There’s just one line of this first example left:
 
 ```rust,ignore
-    println!("You guessed: {}", input);
+    println!("You guessed: {}", guess);
 }
 ```
 
 This prints out the string we saved our input in. The `{}`s are a placeholder,
-and so we pass it `input` as an argument. If we had multiple `{}`s, we would
+and so we pass it `guess` as an argument. If we had multiple `{}`s, we would
 pass multiple arguments:
 
 ```rust
@@ -410,29 +410,24 @@ $ cargo build
    Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
 ```
 
-So, we told Cargo we wanted any version of `rand`, and so it fetched the latest
-version at the time this was written, `v0.3.8`. But what happens when next
-week, version `v0.3.9` comes out, with an important bugfix? While getting
-bugfixes is important, what if `0.3.9` contains a regression that breaks our
-code?
+So, we told Cargo we wanted any version of `rand`, and so it fetched the
+latest version at the time this was written, `v0.3.8`. But what happens
+when next week, version `v0.4.0` comes out, which changes something with
+`rand`, and it includes a breaking change? After all, a `v0.y.z` version
+in SemVer can change every release.
 
 The answer to this problem is the `Cargo.lock` file you’ll now find in your
 project directory. When you build your project for the first time, Cargo
 figures out all of the versions that fit your criteria, and then writes them
 to the `Cargo.lock` file. When you build your project in the future, Cargo
 will see that the `Cargo.lock` file exists, and then use that specific version
 rather than do all the work of figuring out versions again. This lets you
-have a repeatable build automatically. In other words, we’ll stay at `0.3.8`
-until we explicitly upgrade, and so will anyone who we share our code with,
-thanks to the lock file.
+have a repeatable build automatically.
 
-What about when we _do_ want to use `v0.3.9`? Cargo has another command,
+What about when we _do_ want to use `v0.4.0`? Cargo has another command,
 `update`, which says ‘ignore the lock, figure out all the latest versions that
 fit what we’ve specified. If that works, write those versions out to the lock
-file’. But, by default, Cargo will only look for versions larger than `0.3.0`
-and smaller than `0.4.0`. If we want to move to `0.4.x`, we’d have to update
-the `Cargo.toml` directly. When we do, the next time we `cargo build`, Cargo
-will update the index and re-evaluate our `rand` requirements.
+file’.
 
 There’s a lot more to say about [Cargo][doccargo] and [its
 ecosystem][doccratesio], but for now, that’s all we need to know. Cargo makes

branches/try/src/doc/trpl/strings.md

@@ -73,13 +73,13 @@ individual bytes, or as codepoints:
 let hachiko = "忠犬ハチ公";
 
 for b in hachiko.as_bytes() {
-    print!("{}, ", b);
+print!("{}, ", b);
 }
 
 println!("");
 
 for c in hachiko.chars() {
-    print!("{}, ", c);
+print!("{}, ", c);
 }
 
 println!("");

branches/try/src/grammar/RustLexer.g4

@@ -8,14 +8,14 @@ lexer grammar RustLexer;
 
 
 tokens {
-    EQ, LT, LE, EQEQ, NE, GE, GT, ANDAND, OROR, NOT, TILDE, PLUS,
+    EQ, LT, LE, EQEQ, NE, GE, GT, ANDAND, OROR, NOT, TILDE, PLUT,
     MINUS, STAR, SLASH, PERCENT, CARET, AND, OR, SHL, SHR, BINOP,
     BINOPEQ, AT, DOT, DOTDOT, DOTDOTDOT, COMMA, SEMI, COLON,
     MOD_SEP, RARROW, FAT_ARROW, LPAREN, RPAREN, LBRACKET, RBRACKET,
-    LBRACE, RBRACE, POUND, DOLLAR, UNDERSCORE, LIT_CHAR, LIT_BYTE,
+    LBRACE, RBRACE, POUND, DOLLAR, UNDERSCORE, LIT_CHAR,
     LIT_INTEGER, LIT_FLOAT, LIT_STR, LIT_STR_RAW, LIT_BINARY,
-    LIT_BINARY_RAW, QUESTION, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
-    COMMENT, SHEBANG, UTF8_BOM
+    LIT_BINARY_RAW, IDENT, LIFETIME, WHITESPACE, DOC_COMMENT,
+    COMMENT, SHEBANG
 }
 
 import xidstart , xidcontinue;

branches/try/src/grammar/verify.rs

@@ -111,7 +111,7 @@ fn parse_token_list(file: &str) -> HashMap<String, token::Token> {
             "LIT_BINARY_RAW"    => token::Literal(token::BinaryRaw(Name(0), 0), None),
             "QUESTION"          => token::Question,
             "SHEBANG"           => token::Shebang(Name(0)),
-            _                   => panic!("Bad token str `{}`", val),
+            _                   => continue,
         };
 
         res.insert(num.to_string(), tok);

branches/try/src/liballoc/boxed.rs

@@ -37,7 +37,7 @@
 //! }
 //! ```
 //!
-//! This will print `Cons(1, Cons(2, Nil))`.
+//! This will print `Cons(1, Box(Cons(2, Box(Nil))))`.
 //!
 //! Recursive structures must be boxed, because if the definition of `Cons` looked like this:
 //!

branches/try/src/libcollections/bit.rs

@@ -89,7 +89,6 @@ use core::hash;
 use core::iter::RandomAccessIterator;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
 use core::iter::{self, FromIterator};
-use core::mem::swap;
 use core::ops::Index;
 use core::slice;
 use core::{u8, u32, usize};
@@ -603,106 +602,6 @@ impl BitVec {
         Iter { bit_vec: self, next_idx: 0, end_idx: self.nbits }
     }
 
-    /// Moves all bits from `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_vec_append_split_off)]
-    /// use std::collections::BitVec;
-    ///
-    /// let mut a = BitVec::from_bytes(&[0b10000000]);
-    /// let mut b = BitVec::from_bytes(&[0b01100001]);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.len(), 16);
-    /// assert_eq!(b.len(), 0);
-    /// assert!(a.eq_vec(&[true, false, false, false, false, false, false, false,
-    ///                    false, true, true, false, false, false, false, true]));
-    /// ```
-    #[unstable(feature = "bit_vec_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn append(&mut self, other: &mut Self) {
-        let b = self.len() % u32::BITS;
-
-        self.nbits += other.len();
-        other.nbits = 0;
-
-        if b == 0 {
-            self.storage.append(&mut other.storage);
-        } else {
-            self.storage.reserve(other.storage.len());
-
-            for block in other.storage.drain(..) {
-                *(self.storage.last_mut().unwrap()) |= block << b;
-                self.storage.push(block >> (u32::BITS - b));
-            }
-        }
-    }
-
-    /// Splits the `BitVec` into two at the given bit,
-    /// retaining the first half in-place and returning the second one.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(collections, bit_vec_append_split_off)]
-    /// use std::collections::BitVec;
-    /// let mut a = BitVec::new();
-    /// a.push(true);
-    /// a.push(false);
-    /// a.push(false);
-    /// a.push(true);
-    ///
-    /// let b = a.split_off(2);
-    ///
-    /// assert_eq!(a.len(), 2);
-    /// assert_eq!(b.len(), 2);
-    /// assert!(a.eq_vec(&[true, false]));
-    /// assert!(b.eq_vec(&[false, true]));
-    /// ```
-    #[unstable(feature = "bit_vec_append_split_off",
-               reason = "recently added as part of collections reform 2")]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        assert!(at <= self.len(), "`at` out of bounds");
-
-        let mut other = BitVec::new();
-
-        if at == 0 {
-            swap(self, &mut other);
-            return other;
-        } else if at == self.len() {
-            return other;
-        }
-
-        let w = at / u32::BITS;
-        let b = at % u32::BITS;
-        other.nbits = self.nbits - at;
-        self.nbits = at;
-        if b == 0 {
-            // Split at block boundary
-            other.storage = self.storage.split_off(w);
-        } else {
-            other.storage.reserve(self.storage.len() - w);
-
-            {
-                let mut iter = self.storage[w..].iter();
-                let mut last = *iter.next().unwrap();
-                for &cur in iter {
-                    other.storage.push((last >> b) | (cur << (u32::BITS - b)));
-                    last = cur;
-                }
-                other.storage.push(last >> b);
-            }
-
-            self.storage.truncate(w+1);
-            self.fix_last_block();
-        }
-
-        other
-    }
-
     /// Returns `true` if all bits are 0.
     ///
     /// # Examples

branches/try/src/libcollections/slice.rs

@@ -996,13 +996,9 @@ impl<T> [T] {
 ////////////////////////////////////////////////////////////////////////////////
 // Extension traits for slices over specific kinds of data
 ////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "collections", reason = "recently changed")]
+#[unstable(feature = "collections", reason = "U should be an associated type")]
 /// An extension trait for concatenating slices
-pub trait SliceConcatExt<T: ?Sized> {
-    #[unstable(feature = "collections", reason = "recently changed")]
-    /// The resulting type after concatenation
-    type Output;
-
+pub trait SliceConcatExt<T: ?Sized, U> {
     /// Flattens a slice of `T` into a single value `U`.
     ///
     /// # Examples
@@ -1011,7 +1007,7 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// assert_eq!(["hello", "world"].concat(), "helloworld");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn concat(&self) -> Self::Output;
+    fn concat(&self) -> U;
 
     /// Flattens a slice of `T` into a single value `U`, placing a given separator between each.
     ///
@@ -1021,12 +1017,10 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// assert_eq!(["hello", "world"].connect(" "), "hello world");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn connect(&self, sep: &T) -> Self::Output;
+    fn connect(&self, sep: &T) -> U;
 }
 
-impl<T: Clone, V: AsRef<[T]>> SliceConcatExt<T> for [V] {
-    type Output = Vec<T>;
-
+impl<T: Clone, V: AsRef<[T]>> SliceConcatExt<T, Vec<T>> for [V] {
     fn concat(&self) -> Vec<T> {
         let size = self.iter().fold(0, |acc, v| acc + v.as_ref().len());
         let mut result = Vec::with_capacity(size);

branches/try/src/libcollections/str.rs

@@ -83,9 +83,7 @@ pub use core::str::pattern;
 Section: Creating a string
 */
 
-impl<S: AsRef<str>> SliceConcatExt<str> for [S] {
-    type Output = String;
-
+impl<S: AsRef<str>> SliceConcatExt<str, String> for [S] {
     fn concat(&self) -> String {
         if self.is_empty() {
             return String::new();