---

yaml
---
r: 206548
b: refs/heads/beta
c: 0749991
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 61c1cf7f74849e087672bbe2f1607e0c83573dca
+refs/heads/beta: 07499918b3dac890cab8f932a3be2ab48be8f447
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

branches/beta/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/beta/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/beta/src/doc/trpl/guessing-game.md

@@ -82,11 +82,11 @@ fn main() {
 
     let mut guess = String::new();
 
-    io::stdin().read_line(&mut guess)
+    let input = io::stdin().read_line(&mut guess)
         .ok()
         .expect("Failed to read line");
 
-    println!("You guessed: {}", guess);
+    println!("You guessed: {}", input);
 }
 ```
 
@@ -302,12 +302,12 @@ project.
 There’s just one line of this first example left:
 
 ```rust,ignore
-    println!("You guessed: {}", guess);
+    println!("You guessed: {}", input);
 }
 ```
 
 This prints out the string we saved our input in. The `{}`s are a placeholder,
-and so we pass it `guess` as an argument. If we had multiple `{}`s, we would
+and so we pass it `input` as an argument. If we had multiple `{}`s, we would
 pass multiple arguments:
 
 ```rust
@@ -358,10 +358,11 @@ rand="0.3.0"
 The `[dependencies]` section of `Cargo.toml` is like the `[package]` section:
 everything that follows it is part of it, until the next section starts.
 Cargo uses the dependencies section to know what dependencies on external
-crates you have, and what versions you require. In this case, we’ve used version `0.3.0`.
-Cargo understands [Semantic Versioning][semver], which is a standard for writing version
-numbers. If we wanted to use the latest version we could use `*` or we could use a range 
-of versions. [Cargo’s documentation][cargodoc] contains more details.
+crates you have, and what versions you require. In this case, we’ve used `*`,
+which means that we’ll use the latest version of `rand`. Cargo understands
+[Semantic Versioning][semver], which is a standard for writing version
+numbers. If we wanted a specific version or range of versions, we could be
+more specific here. [Cargo’s documentation][cargodoc] contains more details.
 
 [semver]: http://semver.org
 [cargodoc]: http://doc.crates.io/crates-io.html
@@ -409,29 +410,24 @@ $ cargo build
    Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
 ```
 
-So, we told Cargo we wanted any `0.3.x` 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
@@ -847,7 +843,7 @@ fn main() {
             Ordering::Less    => println!("Too small!"),
             Ordering::Greater => println!("Too big!"),
             Ordering::Equal   => {
-                println!("You win!");
+                println!("You win!"),
                 break;
             }
         }
@@ -964,6 +960,8 @@ fn main() {
 
     let secret_number = rand::thread_rng().gen_range(1, 101);
 
+    println!("The secret number is: {}", secret_number);
+
     loop {
         println!("Please input your guess.");
 

branches/beta/src/doc/trpl/mutability.md

@@ -85,7 +85,7 @@ safety, and the mechanism by which Rust guarantees it, the
 > You may have one or the other of these two kinds of borrows, but not both at
 > the same time:
 > 
-> * one or more references (`&T`) to a resource.
+> * 0 to N references (`&T`) to a resource.
 > * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html

branches/beta/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/beta/src/doc/trpl/traits.md

@@ -192,7 +192,7 @@ Here’s the error:
 ```text
 error: type `std::fs::File` does not implement any method in scope named `write`
 
-let result = f.write(b”whatever”);
+let result = f.write(b"whatever");
                ^~~~~~~~~~~~~~~~~~
 ```
 

branches/beta/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/beta/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/beta/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/beta/src/libcollections/vec.rs

@@ -67,7 +67,7 @@ use core::intrinsics::assume;
 use core::iter::{repeat, FromIterator};
 use core::marker::PhantomData;
 use core::mem;
-use core::ops::{Index, IndexMut, Deref};
+use core::ops::{Index, IndexMut, Deref, Add};
 use core::ops;
 use core::ptr;
 use core::ptr::Unique;
@@ -1622,6 +1622,17 @@ impl<T: Ord> Ord for Vec<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
+    type Output = Vec<T>;
+
+    #[inline]
+    fn add(mut self, rhs: &[T]) -> Vec<T> {
+        self.push_all(rhs);
+        self
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {

branches/beta/src/libcore/iter.rs

@@ -602,8 +602,6 @@ pub trait Iterator {
     /// Performs a fold operation over the entire iterator, returning the
     /// eventual state at the end of the iteration.
     ///
-    /// This operation is sometimes called 'reduce' or 'inject'.
-    ///
     /// # Examples
     ///
     /// ```

branches/beta/src/libcore/slice.rs

@@ -631,14 +631,8 @@ fn size_from_ptr<T>(_: *const T) -> usize {
 }
 
 
-// Use macros to be generic over const/mut
-//
-// They require non-negative `$by` because otherwise the expression
-// `(ptr as usize + $by)` would interpret `-1` as `usize::MAX` (and
-// thus trigger a panic when overflow checks are on).
-
-// Use this to do `$ptr + $by`, where `$by` is non-negative.
-macro_rules! slice_add_offset {
+// Use macro to be generic over const/mut
+macro_rules! slice_offset {
     ($ptr:expr, $by:expr) => {{
         let ptr = $ptr;
         if size_from_ptr(ptr) == 0 {
@@ -649,18 +643,6 @@ macro_rules! slice_add_offset {
     }};
 }
 
-// Use this to do `$ptr - $by`, where `$by` is non-negative.
-macro_rules! slice_sub_offset {
-    ($ptr:expr, $by:expr) => {{
-        let ptr = $ptr;
-        if size_from_ptr(ptr) == 0 {
-            transmute(ptr as usize - $by)
-        } else {
-            ptr.offset(-$by)
-        }
-    }};
-}
-
 macro_rules! slice_ref {
     ($ptr:expr) => {{
         let ptr = $ptr;
@@ -690,7 +672,7 @@ macro_rules! iterator {
                         None
                     } else {
                         let old = self.ptr;
-                        self.ptr = slice_add_offset!(self.ptr, 1);
+                        self.ptr = slice_offset!(self.ptr, 1);
                         Some(slice_ref!(old))
                     }
                 }
@@ -732,7 +714,7 @@ macro_rules! iterator {
                     if self.end == self.ptr {
                         None
                     } else {
-                        self.end = slice_sub_offset!(self.end, 1);
+                        self.end = slice_offset!(self.end, -1);
                         Some(slice_ref!(self.end))
                     }
                 }
@@ -794,7 +776,7 @@ impl<'a, T> Iter<'a, T> {
     fn iter_nth(&mut self, n: usize) -> Option<&'a T> {
         match self.as_slice().get(n) {
             Some(elem_ref) => unsafe {
-                self.ptr = slice_add_offset!(elem_ref as *const _, 1);
+                self.ptr = slice_offset!(elem_ref as *const _, 1);
                 Some(slice_ref!(elem_ref))
             },
             None => {
@@ -867,7 +849,7 @@ impl<'a, T> IterMut<'a, T> {
     fn iter_nth(&mut self, n: usize) -> Option<&'a mut T> {
         match make_mut_slice!(T => &'a mut [T]: self.ptr, self.end).get_mut(n) {
             Some(elem_ref) => unsafe {
-                self.ptr = slice_add_offset!(elem_ref as *mut _, 1);
+                self.ptr = slice_offset!(elem_ref as *mut _, 1);
                 Some(slice_ref!(elem_ref))
             },
             None => {

branches/beta/src/liblibc/lib.rs

@@ -3624,30 +3624,6 @@ pub mod consts {
             pub const IPV6_DROP_MEMBERSHIP: c_int = 21;
 
             pub const TCP_NODELAY: c_int = 1;
-            pub const TCP_MAXSEG: c_int = 2;
-            pub const TCP_CORK: c_int = 3;
-            pub const TCP_KEEPIDLE: c_int = 4;
-            pub const TCP_KEEPINTVL: c_int = 5;
-            pub const TCP_KEEPCNT: c_int = 6;
-            pub const TCP_SYNCNT: c_int = 7;
-            pub const TCP_LINGER2: c_int = 8;
-            pub const TCP_DEFER_ACCEPT: c_int = 9;
-            pub const TCP_WINDOW_CLAMP: c_int = 10;
-            pub const TCP_INFO: c_int = 11;
-            pub const TCP_QUICKACK: c_int = 12;
-            pub const TCP_CONGESTION: c_int = 13;
-            pub const TCP_MD5SIG: c_int = 14;
-            pub const TCP_COOKIE_TRANSACTIONS: c_int = 15;
-            pub const TCP_THIN_LINEAR_TIMEOUTS: c_int = 16;
-            pub const TCP_THIN_DUPACK: c_int = 17;
-            pub const TCP_USER_TIMEOUT: c_int = 18;
-            pub const TCP_REPAIR: c_int = 19;
-            pub const TCP_REPAIR_QUEUE: c_int = 20;
-            pub const TCP_QUEUE_SEQ: c_int = 21;
-            pub const TCP_REPAIR_OPTIONS: c_int = 22;
-            pub const TCP_FASTOPEN: c_int = 23;
-            pub const TCP_TIMESTAMP: c_int = 24;
-
             pub const SOL_SOCKET: c_int = 65535;
 
             pub const SO_DEBUG: c_int = 0x0001;