---

yaml
---
r: 274213
b: refs/heads/stable
c: 6a6e9a9
h: refs/heads/master
i:
  274211: 0f92959

Author: vessd

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: b0b1df84254fb6b6fc9eb11cceea8441c6cf596d
+refs/heads/stable: 6a6e9a987a0c11368f921057fdb52f3719aa555f
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/COPYRIGHT

@@ -7,7 +7,7 @@ terms.
 Longer version:
 
 The Rust Project is copyright 2016, The Rust Project
-Developers.
+Developers (given in the file AUTHORS.txt).
 
 Licensed under the Apache License, Version 2.0
 <LICENSE-APACHE or

branches/stable/src/doc/book/bibliography.md

@@ -80,4 +80,3 @@ Language](http://www.cs.indiana.edu/~eholk/papers/hips2013.pdf). Early GPU work
   Rust](http://munksgaard.me/papers/laumann-munksgaard-larsen.pdf). Philip
   Munksgaard's master's thesis. Research for Servo.
 * [Ownership is Theft: Experiences Building an Embedded OS in Rust - Amit Levy, et. al.](http://amitlevy.com/papers/tock-plos2015.pdf)
-* [You can't spell trust without Rust](https://raw.githubusercontent.com/Gankro/thesis/master/thesis.pdf). Alexis Beingessner's master's thesis.

branches/stable/src/doc/book/getting-started.md

@@ -111,7 +111,7 @@ If we're on Linux or a Mac, all we need to do is open a terminal and type this:
 $ curl -sSf https://static.rust-lang.org/rustup.sh | sh
 ```
 
-This will download a script, and start the installation. If it all goes well,
+This will download a script, and stat the installation. If it all goes well,
 you’ll see this appear:
 
 ```text

branches/stable/src/doc/book/guessing-game.md

@@ -908,6 +908,7 @@ let guess: u32 = match guess.trim().parse() {
 ```
 
 This is how you generally move from ‘crash on error’ to ‘actually handle the
+error’, by switching from `expect()` to a `match` statement. The `Result`
 returned by `parse()` is an `enum`  like `Ordering`, but in this case, each
 variant has some data associated with it: `Ok` is a success, and `Err` is a
 failure. Each contains more information: the successfully parsed integer, or an

branches/stable/src/doc/book/no-stdlib.md

@@ -77,11 +77,10 @@ The compiler currently makes a few assumptions about symbols which are available
 in the executable to call. Normally these functions are provided by the standard
 library, but without it you must define your own.
 
-The first of these two functions, `eh_personality`, is used by the failure
-mechanisms of the compiler. This is often mapped to GCC's personality function
-(see the [libstd implementation][unwind] for more information), but crates
-which do not trigger a panic can be assured that this function is never
-called. The second function, `panic_fmt`, is also used by the failure
-mechanisms of the compiler.
-
-[unwind]: https://github.com/rust-lang/rust/blob/master/src/libstd/sys/common/unwind/gcc.rs
+The first of these two functions, `eh_personality`, is used by the
+failure mechanisms of the compiler. This is often mapped to GCC's
+personality function (see the
+[libstd implementation](../std/rt/unwind/index.html) for more
+information), but crates which do not trigger a panic can be assured
+that this function is never called. The second function, `panic_fmt`, is
+also used by the failure mechanisms of the compiler.

branches/stable/src/doc/book/primitive-types.md

@@ -164,9 +164,6 @@ copying. For example, you might want to reference only one line of a file read
 into memory. By nature, a slice is not created directly, but from an existing
 variable binding. Slices have a defined length, can be mutable or immutable.
 
-Internally, slices are represented as a pointer to the beginning of the data 
-and a length.
-
 ## Slicing syntax
 
 You can use a combo of `&` and `[]` to create a slice from various things. The

branches/stable/src/doc/book/traits.md

@@ -277,22 +277,16 @@ This will compile without error.
 This means that even if someone does something bad like add methods to `i32`,
 it won’t affect you, unless you `use` that trait.
 
-There’s one more restriction on implementing traits: either the trait
-or the type you’re implementing it for must be defined by you. Or more
-precisely, one of them must be defined in the same crate as the `impl`
-you're writing. For more on Rust's module and package system, see the
-chapter on [crates and modules][cm].
-
-So, we could implement the `HasArea` type for `i32`, because we defined
-`HasArea` in our code. But if we tried to implement `ToString`, a trait
-provided by Rust, for `i32`, we could not, because neither the trait nor
-the type are defined in our crate.
+There’s one more restriction on implementing traits: either the trait, or the
+type you’re writing the `impl` for, must be defined by you. So, we could
+implement the `HasArea` type for `i32`, because `HasArea` is in our code. But
+if we tried to implement `ToString`, a trait provided by Rust, for `i32`, we could
+not, because neither the trait nor the type are in our code.
 
 One last thing about traits: generic functions with a trait bound use
 ‘monomorphization’ (mono: one, morph: form), so they are statically dispatched.
 What’s that mean? Check out the chapter on [trait objects][to] for more details.
 
-[cm]: crates-and-modules.html
 [to]: trait-objects.html
 
 # Multiple trait bounds

branches/stable/src/doc/version_info.html.template

@@ -1,5 +1,5 @@
 <div id="versioninfo">
-  <img src="https://www.rust-lang.org/logos/rust-logo-32x32-blk.png" width="32" height="32" alt="Rust logo"><br>
+  <img src="https://www.rust-lang.org/logos/rust-logo-32x32-blk.png" width="32" height="32" alt><br>
   <span class="white-sticker"><a href="https://www.rust-lang.org">Rust</a> VERSION</span><br>
   <a href="https://github.com/rust-lang/rust/commit/STAMP"
     class="hash white-sticker">SHORT_HASH</a>

branches/stable/src/libcollections/btree/map.rs

@@ -1194,17 +1194,17 @@ unsafe fn unwrap_unchecked<T>(val: Option<T>) -> T {
 }
 
 impl<K, V> BTreeMap<K, V> {
-    /// Gets an iterator over the entries of the map, sorted by key.
+    /// Gets an iterator over the entries of the map.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::collections::BTreeMap;
     ///
     /// let mut map = BTreeMap::new();
-    /// map.insert(3, "c");
-    /// map.insert(2, "b");
     /// map.insert(1, "a");
+    /// map.insert(2, "b");
+    /// map.insert(3, "c");
     ///
     /// for (key, value) in map.iter() {
     ///     println!("{}: {}", key, value);
@@ -1224,7 +1224,7 @@ impl<K, V> BTreeMap<K, V> {
         }
     }
 
-    /// Gets a mutable iterator over the entries of the map, sorted by key.
+    /// Gets a mutable iterator over the entries of the map.
     ///
     /// # Examples
     ///
@@ -1257,16 +1257,16 @@ impl<K, V> BTreeMap<K, V> {
         }
     }
 
-    /// Gets an iterator over the keys of the map, in sorted order.
+    /// Gets an iterator over the keys of the map.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::collections::BTreeMap;
     ///
     /// let mut a = BTreeMap::new();
-    /// a.insert(2, "b");
     /// a.insert(1, "a");
+    /// a.insert(2, "b");
     ///
     /// let keys: Vec<_> = a.keys().cloned().collect();
     /// assert_eq!(keys, [1, 2]);
@@ -1276,19 +1276,19 @@ impl<K, V> BTreeMap<K, V> {
         Keys { inner: self.iter() }
     }
 
-    /// Gets an iterator over the values of the map, in order by key.
+    /// Gets an iterator over the values of the map.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::collections::BTreeMap;
     ///
     /// let mut a = BTreeMap::new();
-    /// a.insert(1, "hello");
-    /// a.insert(2, "goodbye");
+    /// a.insert(1, "a");
+    /// a.insert(2, "b");
     ///
     /// let values: Vec<&str> = a.values().cloned().collect();
-    /// assert_eq!(values, ["hello", "goodbye"]);
+    /// assert_eq!(values, ["a", "b"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn values<'a>(&'a self) -> Values<'a, K, V> {

branches/stable/src/librustc_borrowck/diagnostics.rs

@@ -124,7 +124,7 @@ fn main() {
     let mut x = Rc::new(RefCell::new(MyStruct{ s: 5u32 }));
     let y = x.clone();
     x.borrow_mut().s = 6;
-    println!("{}", x.borrow().s);
+    println!("{}", x.borrow.s);
 }
 ```
 

branches/stable/src/librustc_resolve/diagnostics.rs

@@ -207,41 +207,7 @@ https://doc.rust-lang.org/reference.html#statements
 E0317: r##"
 User-defined types or type parameters cannot shadow the primitive types.
 This error indicates you tried to define a type, struct or enum with the same
-name as an existing primitive type:
-
-```
-struct u8 {
-    // ...
-}
-```
-
-To fix this, simply name it something else.
-
-Such an error may also occur if you define a type parameter which shadows a
-primitive type. An example would be something like:
-
-```
-impl<u8> MyTrait for Option<u8> {
-    // ...
-}
-```
-
-In such a case, if you meant for `u8` to be a generic type parameter (i.e. any
-type can be used in its place), use something like `T` instead:
-
-```
-impl<T> MyTrait for Option<T> {
-    // ...
-}
-```
-
-On the other hand, if you wished to refer to the specific type `u8`, remove it
-from the type parameter list:
-
-```
-impl MyTrait for Option<u8> {
-    // ...
-}
+name as an existing primitive type.
 
 See the Types section of the reference for more information about the primitive
 types:

branches/stable/src/librustc_typeck/collect.rs

@@ -1918,8 +1918,8 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>,
                 lint::builtin::INVALID_TYPE_PARAM_DEFAULT,
                 param.id,
                 param.span,
-                format!("defaults for type parameters are only allowed in `struct`, \
-                         `enum`, `type`, or `trait` definitions."));
+                format!("defaults for type parameters are only allowed on type definitions, \
+                         like `struct` or `enum`"));
         }
     }
 

branches/stable/src/librustc_typeck/diagnostics.rs

@@ -2269,8 +2269,6 @@ struct MyType<T>(T);
 impl<T> ForeignTrait for MyType<T> { ... } // Ok
 ```
 
-Please note that a type alias is not sufficient.
-
 For another example of an error, suppose there's another trait defined in `foo`
 named `ForeignTrait2` that takes two type parameters. Then this `impl` results
 in the same rule violation:

branches/stable/src/librustdoc/html/format.rs

@@ -456,44 +456,23 @@ impl fmt::Display for clean::Type {
                        decl.decl)
             }
             clean::Tuple(ref typs) => {
-                match &**typs {
-                    [] => primitive_link(f, clean::PrimitiveTuple, "()"),
-                    [ref one] => {
-                        try!(primitive_link(f, clean::PrimitiveTuple, "("));
-                        try!(write!(f, "{}", one));
-                        primitive_link(f, clean::PrimitiveTuple, ")")
-                    }
-                    many => {
-                        try!(primitive_link(f, clean::PrimitiveTuple, "("));
-                        try!(write!(f, "{}", CommaSep(&many)));
-                        primitive_link(f, clean::PrimitiveTuple, ")")
-                    }
-                }
+                primitive_link(f, clean::PrimitiveTuple,
+                               &*match &**typs {
+                                    [ref one] => format!("({},)", one),
+                                    many => format!("({})", CommaSep(&many)),
+                               })
             }
             clean::Vector(ref t) => {
-                try!(primitive_link(f, clean::Slice, &format!("[")));
-                try!(write!(f, "{}", t));
-                primitive_link(f, clean::Slice, &format!("]"))
+                primitive_link(f, clean::Slice, &format!("[{}]", **t))
             }
             clean::FixedVector(ref t, ref s) => {
-                try!(primitive_link(f, clean::PrimitiveType::Array, "["));
-                try!(write!(f, "{}", t));
                 primitive_link(f, clean::PrimitiveType::Array,
-                               &format!("; {}]", *s))
+                               &format!("[{}; {}]", **t, *s))
             }
             clean::Bottom => f.write_str("!"),
             clean::RawPointer(m, ref t) => {
-                match **t {
-                    clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} => {
-                        primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
-                                       &format!("*{}{}", RawMutableSpace(m), t))
-                    }
-                    _ => {
-                        try!(primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
-                                            &format!("*{}", RawMutableSpace(m))));
-                        write!(f, "{}", t)
-                    }
-                }
+                primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
+                               &format!("*{}{}", RawMutableSpace(m), **t))
             }
             clean::BorrowedRef{ lifetime: ref l, mutability, type_: ref ty} => {
                 let lt = match *l {

branches/stable/src/librustdoc/html/layout.rs

@@ -148,7 +148,7 @@ r##"<!DOCTYPE html>
         "".to_string()
     } else {
         format!("<a href='{}{}/index.html'>\
-                 <img src='{}' alt='logo' width='100'></a>",
+                 <img src='{}' alt='' width='100'></a>",
                 page.root_path, layout.krate,
                 layout.logo)
     },

branches/stable/src/librustdoc/html/static/rustdoc.css

@@ -383,7 +383,7 @@ a {
 }
 
 .content span.enum, .content a.enum, .block a.current.enum { color: #5e9766; }
-.content span.struct, .content a.struct, .block a.current.struct { color: #df3600; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #e53700; }
 .content a.type { color: #e57300; }
 .content a.macro { color: #068000; }
 .block a.current.crate { font-weight: 500; }

branches/stable/src/librustdoc/html/static/styles/main.css

@@ -106,14 +106,14 @@ a {
 }
 
 .docblock a, .stability a {
-    color: #3873AD;
+    color: #4e8bca;
 }
 
 a.test-arrow {
     color: #f5f5f5;
 }
 
-.content span.trait, .content a.trait, .block a.current.trait { color: #7c5af3; }
+.content span.trait, .content a.trait, .block a.current.trait { color: #8866ff; }
 
 .search-input {
     color: #555;

branches/stable/src/libstd/collections/hash/map.rs

@@ -272,35 +272,6 @@ fn test_resize_policy() {
 /// }
 /// ```
 ///
-/// `HashMap` also implements an [`Entry API`](#method.entry), which allows
-/// for more complex methods of getting, setting, updating and removing keys and
-/// their values:
-///
-/// ```
-/// use std::collections::HashMap;
-///
-/// // type inference lets us omit an explicit type signature (which
-/// // would be `HashMap<&str, u8>` in this example).
-/// let mut player_stats = HashMap::new();
-///
-/// fn random_stat_buff() -> u8 {
-///   // could actually return some random value here - let's just return
-///   // some fixed value for now
-///   42
-/// }
-///
-/// // insert a key only if it doesn't already exist
-/// player_stats.entry("health").or_insert(100);
-///
-/// // insert a key using a function that provides a new value only if it
-/// // doesn't already exist
-/// player_stats.entry("defence").or_insert_with(random_stat_buff);
-///
-/// // update a key, guarding against the key possibly not being set
-/// let stat = player_stats.entry("attack").or_insert(100);
-/// *stat += random_stat_buff();
-/// ```
-///
 /// The easiest way to use `HashMap` with a custom type as key is to derive `Eq` and `Hash`.
 /// We must also derive `PartialEq`.
 ///

branches/stable/src/libstd/ffi/c_str.rs

@@ -407,14 +407,16 @@ impl CStr {
     /// # fn main() {
     /// use std::ffi::CStr;
     /// use std::os::raw::c_char;
+    /// use std::str;
     ///
     /// extern {
     ///     fn my_string() -> *const c_char;
     /// }
     ///
     /// unsafe {
     ///     let slice = CStr::from_ptr(my_string());
-    ///     println!("string returned: {}", slice.to_str().unwrap());
+    ///     println!("string returned: {}",
+    ///              str::from_utf8(slice.to_bytes()).unwrap());
     /// }
     /// # }
     /// ```