Auto merge of rust-lang#31148 - steveklabnik:rollup, r=steveklabnik

- Successful merges: rust-lang#30997, rust-lang#31019, rust-lang#31031, rust-lang#31035, rust-lang#31045, rust-lang#31050, rust-lang#31054, rust-lang#31055, rust-lang#31061, rust-lang#31088, rust-lang#31090, rust-lang#31111, rust-lang#31113, rust-lang#31128, rust-lang#31130, rust-lang#31136, rust-lang#31145, rust-lang#31146 - Failed merges: rust-lang#30932

Author: bors

src/doc/book/bibliography.md

@@ -80,3 +80,4 @@ 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.

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 stat the installation. If it all goes well,
+This will download a script, and start the installation. If it all goes well,
 you’ll see this appear:
 
 ```text

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

src/doc/book/no-stdlib.md

@@ -77,10 +77,11 @@ 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](../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.
+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

src/doc/book/traits.md

@@ -277,16 +277,22 @@ 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 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.
+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.
 
 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

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><br>
+ <img src="https://www.rust-lang.org/logos/rust-logo-32x32-blk.png" width="32" height="32" alt="Rust logo"><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>

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.
+ /// Gets an iterator over the entries of the map, sorted by key.
  ///
  /// # Examples
  ///
  /// ```
  /// use std::collections::BTreeMap;
  ///
  /// let mut map = BTreeMap::new();
- /// map.insert(1, "a");
- /// map.insert(2, "b");
  /// map.insert(3, "c");
+ /// map.insert(2, "b");
+ /// map.insert(1, "a");
  ///
  /// 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.
+ /// Gets a mutable iterator over the entries of the map, sorted by key.
  ///
  /// # Examples
  ///
@@ -1257,16 +1257,16 @@ impl<K, V> BTreeMap<K, V> {
  }
  }
 
- /// Gets an iterator over the keys of the map.
+ /// Gets an iterator over the keys of the map, in sorted order.
  ///
  /// # Examples
  ///
  /// ```
  /// use std::collections::BTreeMap;
  ///
  /// let mut a = BTreeMap::new();
- /// a.insert(1, "a");
  /// a.insert(2, "b");
+ /// a.insert(1, "a");
  ///
  /// 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.
+ /// Gets an iterator over the values of the map, in order by key.
  ///
  /// # Examples
  ///
  /// ```
  /// use std::collections::BTreeMap;
  ///
  /// let mut a = BTreeMap::new();
- /// a.insert(1, "a");
- /// a.insert(2, "b");
+ /// a.insert(1, "hello");
+ /// a.insert(2, "goodbye");
  ///
  /// let values: Vec<&str> = a.values().cloned().collect();
- /// assert_eq!(values, ["a", "b"]);
+ /// assert_eq!(values, ["hello", "goodbye"]);
  /// ```
  #[stable(feature = "rust1", since = "1.0.0")]
  pub fn values<'a>(&'a self) -> Values<'a, K, V> {

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);
 }
 ```
 

src/librustc_resolve/diagnostics.rs

@@ -207,7 +207,41 @@ 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.
+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> {
+ // ...
+}
 
 See the Types section of the reference for more information about the primitive
 types:

src/librustc_typeck/diagnostics.rs

@@ -2269,6 +2269,8 @@ 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: