Auto merge of #36536 - jonathandturner:rollup, r=jonathandturner

Rollup of 8 pull requests

- Successful merges: #36383, #36424, #36480, #36484, #36505, #36509, #36519, #36521
- Failed merges:

src/bootstrap/bootstrap.py

@@ -269,6 +269,7 @@ class RustBuild:
             sys.exit(ret)
 
     def build_triple(self):
+        default_encoding = sys.getdefaultencoding()
         config = self.get_toml('build')
         if config:
             return config
@@ -276,8 +277,8 @@ class RustBuild:
         if config:
             return config
         try:
-            ostype = subprocess.check_output(['uname', '-s']).strip()
-            cputype = subprocess.check_output(['uname', '-m']).strip()
+            ostype = subprocess.check_output(['uname', '-s']).strip().decode(default_encoding)
+            cputype = subprocess.check_output(['uname', '-m']).strip().decode(default_encoding)
         except (subprocess.CalledProcessError, WindowsError):
             if sys.platform == 'win32':
                 return 'x86_64-pc-windows-msvc'
@@ -289,7 +290,8 @@ class RustBuild:
         # Darwin's `uname -s` lies and always returns i386. We have to use
         # sysctl instead.
         if ostype == 'Darwin' and cputype == 'i686':
-            sysctl = subprocess.check_output(['sysctl', 'hw.optional.x86_64'])
+            args = ['sysctl', 'hw.optional.x86_64']
+            sysctl = subprocess.check_output(args).decode(default_encoding)
             if ': 1' in sysctl:
                 cputype = 'x86_64'
 

src/doc/book/traits.md

@@ -291,7 +291,7 @@ let result = f.write(buf);
 
 We need to `use` the `Write` trait first:
 
-```rust,ignore
+```rust,no_run
 use std::io::Write;
 
 let mut f = std::fs::File::create("foo.txt").expect("Couldn’t create foo.txt");

src/libcore/convert.rs

@@ -92,6 +92,22 @@ pub trait AsRef<T: ?Sized> {
 /// [`Option<T>`]: ../../std/option/enum.Option.html
 /// [`Result<T, E>`]: ../../std/result/enum.Result.html
 ///
+/// # Examples
+///
+/// [`Box<T>`] implements `AsMut<T>`:
+///
+/// [`Box<T>`]: ../../std/boxed/struct.Box.html
+///
+/// ```
+/// fn add_one<T: AsMut<u64>>(num: &mut T) {
+///     *num.as_mut() += 1;
+/// }
+///
+/// let mut boxed_num = Box::new(0);
+/// add_one(&mut boxed_num);
+/// assert_eq!(*boxed_num, 1);
+/// ```
+///
 /// # Generic Impls
 ///
 /// - `AsMut` auto-dereferences if the inner type is a reference or a mutable

src/libcore/marker.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Primitive traits and marker types representing basic 'kinds' of types.
+//! Primitive traits and types representing basic properties of types.
 //!
 //! Rust types can be classified in various useful ways according to
-//! intrinsic properties of the type. These classifications, often called
-//! 'kinds', are represented as traits.
+//! their intrinsic properties. These classifications are represented
+//! as traits.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
@@ -22,7 +22,21 @@
 
 /// Types that can be transferred across thread boundaries.
 ///
-/// This trait is automatically derived when the compiler determines it's appropriate.
+/// This trait is automatically implemented when the compiler determines it's
+/// appropriate.
+///
+/// An example of a non-`Send` type is the reference-counting pointer
+/// [`rc::Rc`][rc]. If two threads attempt to clone `Rc`s that point to the same
+/// reference-counted value, they might try to update the reference count at the
+/// same time, which is [undefined behavior][ub] because `Rc` doesn't use atomic
+/// operations. Its cousin [`sync::Arc`][arc] does use atomic operations (incurring
+/// some overhead) and thus is `Send`.
+///
+/// See [the Nomicon](../../nomicon/send-and-sync.html) for more details.
+///
+/// [rc]: ../../std/rc/struct.Rc.html
+/// [arc]: ../../std/sync/struct.Arc.html
+/// [ub]: ../../reference.html#behavior-considered-undefined
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "send"]
 #[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"]
@@ -38,10 +52,10 @@ impl<T: ?Sized> !Send for *const T { }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> !Send for *mut T { }
 
-/// Types with a constant size known at compile-time.
+/// Types with a constant size known at compile time.
 ///
-/// All type parameters which can be bounded have an implicit bound of `Sized`. The special syntax
-/// `?Sized` can be used to remove this bound if it is not appropriate.
+/// All type parameters have an implicit bound of `Sized`. The special syntax
+/// `?Sized` can be used to remove this bound if it's not appropriate.
 ///
 /// ```
 /// # #![allow(dead_code)]
@@ -51,6 +65,26 @@ impl<T: ?Sized> !Send for *mut T { }
 /// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]
 /// struct BarUse(Bar<[i32]>); // OK
 /// ```
+///
+/// The one exception is the implicit `Self` type of a trait, which does not
+/// get an implicit `Sized` bound. This is because a `Sized` bound prevents
+/// the trait from being used to form a [trait object]:
+///
+/// ```
+/// # #![allow(unused_variables)]
+/// trait Foo { }
+/// trait Bar: Sized { }
+///
+/// struct Impl;
+/// impl Foo for Impl { }
+/// impl Bar for Impl { }
+///
+/// let x: &Foo = &Impl;    // OK
+/// // let y: &Bar = &Impl; // error: the trait `Bar` cannot
+///                         // be made into an object
+/// ```
+///
+/// [trait object]: ../../book/trait-objects.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "sized"]
 #[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
@@ -59,14 +93,27 @@ pub trait Sized {
     // Empty.
 }
 
-/// Types that can be "unsized" to a dynamically sized type.
+/// Types that can be "unsized" to a dynamically-sized type.
+///
+/// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>` and
+/// `Unsize<fmt::Debug>`.
+///
+/// All implementations of `Unsize` are provided automatically by the compiler.
+///
+/// `Unsize` is used along with [`ops::CoerceUnsized`][coerceunsized] to allow
+/// "user-defined" containers such as [`rc::Rc`][rc] to contain dynamically-sized
+/// types. See the [DST coercion RFC][RFC982] for more details.
+///
+/// [coerceunsized]: ../ops/trait.CoerceUnsized.html
+/// [rc]: ../../std/rc/struct.Rc.html
+/// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
 #[unstable(feature = "unsize", issue = "27732")]
 #[lang="unsize"]
 pub trait Unsize<T: ?Sized> {
     // Empty.
 }
 
-/// Types that can be copied by simply copying bits (i.e. `memcpy`).
+/// Types whose values can be duplicated simply by copying bits.
 ///
 /// By default, variable bindings have 'move semantics.' In other
 /// words:
@@ -87,7 +134,8 @@ pub trait Unsize<T: ?Sized> {
 /// However, if a type implements `Copy`, it instead has 'copy semantics':
 ///
 /// ```
-/// // we can just derive a `Copy` implementation
+/// // We can derive a `Copy` implementation. `Clone` is also required, as it's
+/// // a supertrait of `Copy`.
 /// #[derive(Debug, Copy, Clone)]
 /// struct Foo;
 ///
@@ -100,13 +148,59 @@ pub trait Unsize<T: ?Sized> {
 /// println!("{:?}", x); // A-OK!
 /// ```
 ///
-/// It's important to note that in these two examples, the only difference is if you are allowed to
-/// access `x` after the assignment: a move is also a bitwise copy under the hood.
+/// It's important to note that in these two examples, the only difference is whether you
+/// are allowed to access `x` after the assignment. Under the hood, both a copy and a move
+/// can result in bits being copied in memory, although this is sometimes optimized away.
+///
+/// ## How can I implement `Copy`?
+///
+/// There are two ways to implement `Copy` on your type. The simplest is to use `derive`:
+///
+/// ```
+/// #[derive(Copy, Clone)]
+/// struct MyStruct;
+/// ```
+///
+/// You can also implement `Copy` and `Clone` manually:
+///
+/// ```
+/// struct MyStruct;
+///
+/// impl Copy for MyStruct { }
+///
+/// impl Clone for MyStruct {
+///     fn clone(&self) -> MyStruct {
+///         *self
+///     }
+/// }
+/// ```
+///
+/// There is a small difference between the two: the `derive` strategy will also place a `Copy`
+/// bound on type parameters, which isn't always desired.
+///
+/// ## What's the difference between `Copy` and `Clone`?
+///
+/// Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of
+/// `Copy` is not overloadable; it is always a simple bit-wise copy.
+///
+/// Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`][clone] can
+/// provide any type-specific behavior necessary to duplicate values safely. For example,
+/// the implementation of `Clone` for [`String`][string] needs to copy the pointed-to string
+/// buffer in the heap. A simple bitwise copy of `String` values would merely copy the
+/// pointer, leading to a double free down the line. For this reason, `String` is `Clone`
+/// but not `Copy`.
+///
+/// `Clone` is a supertrait of `Copy`, so everything which is `Copy` must also implement
+/// `Clone`. If a type is `Copy` then its `Clone` implementation need only return `*self`
+/// (see the example above).
+///
+/// [clone]: ../clone/trait.Clone.html
+/// [string]: ../../std/string/struct.String.html
 ///
 /// ## When can my type be `Copy`?
 ///
 /// A type can implement `Copy` if all of its components implement `Copy`. For example, this
-/// `struct` can be `Copy`:
+/// struct can be `Copy`:
 ///
 /// ```
 /// # #[allow(dead_code)]
@@ -116,7 +210,8 @@ pub trait Unsize<T: ?Sized> {
 /// }
 /// ```
 ///
-/// A `struct` can be `Copy`, and `i32` is `Copy`, so therefore, `Point` is eligible to be `Copy`.
+/// A struct can be `Copy`, and `i32` is `Copy`, therefore `Point` is eligible to be `Copy`.
+/// By contrast, consider
 ///
 /// ```
 /// # #![allow(dead_code)]
@@ -126,57 +221,35 @@ pub trait Unsize<T: ?Sized> {
 /// }
 /// ```
 ///
-/// The `PointList` `struct` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we
+/// The struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we
 /// attempt to derive a `Copy` implementation, we'll get an error:
 ///
 /// ```text
 /// the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`
 /// ```
 ///
-/// ## When can my type _not_ be `Copy`?
+/// ## When *can't* my type be `Copy`?
 ///
 /// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
-/// mutable reference, and copying [`String`] would result in two attempts to free the same buffer.
+/// mutable reference. Copying [`String`] would duplicate responsibility for managing the `String`'s
+/// buffer, leading to a double free.
 ///
 /// Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's
 /// managing some resource besides its own [`size_of::<T>()`] bytes.
 ///
-/// ## What if I derive `Copy` on a type that can't?
-///
-/// If you try to derive `Copy` on a struct or enum, you will get a compile-time error.
-/// Specifically, with structs you'll get [E0204](https://doc.rust-lang.org/error-index.html#E0204)
-/// and with enums you'll get [E0205](https://doc.rust-lang.org/error-index.html#E0205).
-///
-/// ## When should my type be `Copy`?
-///
-/// Generally speaking, if your type _can_ implement `Copy`, it should. There's one important thing
-/// to consider though: if you think your type may _not_ be able to implement `Copy` in the future,
-/// then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking
-/// change: that second example would fail to compile if we made `Foo` non-`Copy`.
+/// If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get a
+/// compile-time error. Specifically, with structs you'll get [E0204] and with enums you'll get
+/// [E0205].
 ///
-/// ## Derivable
+/// [E0204]: https://doc.rust-lang.org/error-index.html#E0204
+/// [E0205]: https://doc.rust-lang.org/error-index.html#E0205
 ///
-/// This trait can be used with `#[derive]` if all of its components implement `Copy` and the type.
+/// ## When *should* my type be `Copy`?
 ///
-/// ## How can I implement `Copy`?
-///
-/// There are two ways to implement `Copy` on your type:
-///
-/// ```
-/// #[derive(Copy, Clone)]
-/// struct MyStruct;
-/// ```
-///
-/// and
-///
-/// ```
-/// struct MyStruct;
-/// impl Copy for MyStruct {}
-/// impl Clone for MyStruct { fn clone(&self) -> MyStruct { *self } }
-/// ```
-///
-/// There is a small difference between the two: the `derive` strategy will also place a `Copy`
-/// bound on type parameters, which isn't always desired.
+/// Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,
+/// that implementing `Copy` is part of the public API of your type. If the type might become
+/// non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to
+/// avoid a breaking API change.
 ///
 /// [`Vec<T>`]: ../../std/vec/struct.Vec.html
 /// [`String`]: ../../std/string/struct.String.html
@@ -188,64 +261,74 @@ pub trait Copy : Clone {
     // Empty.
 }
 
-/// Types that can be safely shared between threads when aliased.
+/// Types for which it is safe to share references between threads.
+///
+/// This trait is automatically implemented when the compiler determines
+/// it's appropriate.
 ///
 /// The precise definition is: a type `T` is `Sync` if `&T` is
-/// thread-safe. In other words, there is no possibility of data races
-/// when passing `&T` references between threads.
-///
-/// As one would expect, primitive types like [`u8`] and [`f64`] are all
-/// `Sync`, and so are simple aggregate types containing them (like
-/// tuples, structs and enums). More instances of basic `Sync` types
-/// include "immutable" types like `&T` and those with simple
-/// inherited mutability, such as [`Box<T>`], [`Vec<T>`] and most other
-/// collection types. (Generic parameters need to be `Sync` for their
-/// container to be `Sync`.)
-///
-/// A somewhat surprising consequence of the definition is `&mut T` is
-/// `Sync` (if `T` is `Sync`) even though it seems that it might
-/// provide unsynchronized mutation. The trick is a mutable reference
-/// stored in an aliasable reference (that is, `& &mut T`) becomes
-/// read-only, as if it were a `& &T`, hence there is no risk of a data
-/// race.
+/// [`Send`][send]. In other words, if there is no possibility of
+/// [undefined behavior][ub] (including data races) when passing
+/// `&T` references between threads.
+///
+/// As one would expect, primitive types like [`u8`][u8] and [`f64`][f64]
+/// are all `Sync`, and so are simple aggregate types containing them,
+/// like tuples, structs and enums. More examples of basic `Sync`
+/// types include "immutable" types like `&T`, and those with simple
+/// inherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and
+/// most other collection types. (Generic parameters need to be `Sync`
+/// for their container to be `Sync`.)
+///
+/// A somewhat surprising consequence of the definition is that `&mut T`
+/// is `Sync` (if `T` is `Sync`) even though it seems like that might
+/// provide unsynchronized mutation. The trick is that a mutable
+/// reference behind a shared reference (that is, `& &mut T`)
+/// becomes read-only, as if it were a `& &T`. Hence there is no risk
+/// of a data race.
 ///
 /// Types that are not `Sync` are those that have "interior
-/// mutability" in a non-thread-safe way, such as [`Cell`] and [`RefCell`]
-/// in [`std::cell`]. These types allow for mutation of their contents
-/// even when in an immutable, aliasable slot, e.g. the contents of
-/// [`&Cell<T>`][`Cell`] can be [`.set`], and do not ensure data races are
-/// impossible, hence they cannot be `Sync`. A higher level example
-/// of a non-`Sync` type is the reference counted pointer
-/// [`std::rc::Rc`][`Rc`], because any reference [`&Rc<T>`][`Rc`] can clone a new
-/// reference, which modifies the reference counts in a non-atomic
-/// way.
-///
-/// For cases when one does need thread-safe interior mutability,
-/// types like the atomics in [`std::sync`][`sync`] and [`Mutex`] / [`RwLock`] in
-/// the [`sync`] crate do ensure that any mutation cannot cause data
-/// races.  Hence these types are `Sync`.
-///
-/// Any types with interior mutability must also use the [`std::cell::UnsafeCell`]
-/// wrapper around the value(s) which can be mutated when behind a `&`
-/// reference; not doing this is undefined behavior (for example,
-/// [`transmute`]-ing from `&T` to `&mut T` is invalid).
+/// mutability" in a non-thread-safe form, such as [`cell::Cell`][cell]
+/// and [`cell::RefCell`][refcell]. These types allow for mutation of
+/// their contents even through an immutable, shared reference. For
+/// example the `set` method on `Cell<T>` takes `&self`, so it requires
+/// only a shared reference `&Cell<T>`. The method performs no
+/// synchronization, thus `Cell` cannot be `Sync`.
 ///
-/// This trait is automatically derived when the compiler determines it's appropriate.
+/// Another example of a non-`Sync` type is the reference-counting
+/// pointer [`rc::Rc`][rc]. Given any reference `&Rc<T>`, you can clone
+/// a new `Rc<T>`, modifying the reference counts in a non-atomic way.
 ///
-/// [`u8`]: ../../std/primitive.u8.html
-/// [`f64`]: ../../std/primitive.f64.html
-/// [`Vec<T>`]: ../../std/vec/struct.Vec.html
-/// [`Box<T>`]: ../../std/boxed/struct.Box.html
-/// [`Cell`]: ../../std/cell/struct.Cell.html
-/// [`RefCell`]: ../../std/cell/struct.RefCell.html
-/// [`std::cell`]: ../../std/cell/index.html
-/// [`.set`]: ../../std/cell/struct.Cell.html#method.set
-/// [`Rc`]: ../../std/rc/struct.Rc.html
-/// [`sync`]: ../../std/sync/index.html
-/// [`Mutex`]: ../../std/sync/struct.Mutex.html
-/// [`RwLock`]: ../../std/sync/struct.RwLock.html
-/// [`std::cell::UnsafeCell`]: ../../std/cell/struct.UnsafeCell.html
-/// [`transmute`]: ../../std/mem/fn.transmute.html
+/// For cases when one does need thread-safe interior mutability,
+/// Rust provides [atomic data types], as well as explicit locking via
+/// [`sync::Mutex`][mutex] and [`sync::RWLock`][rwlock]. These types
+/// ensure that any mutation cannot cause data races, hence the types
+/// are `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe
+/// analogue of `Rc`.
+///
+/// Any types with interior mutability must also use the
+/// [`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which
+/// can be mutated through a shared reference. Failing to doing this is
+/// [undefined behavior][ub]. For example, [`transmute`][transmute]-ing
+/// from `&T` to `&mut T` is invalid.
+///
+/// See [the Nomicon](../../nomicon/send-and-sync.html) for more
+/// details about `Sync`.
+///
+/// [send]: trait.Send.html
+/// [u8]: ../../std/primitive.u8.html
+/// [f64]: ../../std/primitive.f64.html
+/// [box]: ../../std/boxed/struct.Box.html
+/// [vec]: ../../std/vec/struct.Vec.html
+/// [cell]: ../cell/struct.Cell.html
+/// [refcell]: ../cell/struct.RefCell.html
+/// [rc]: ../../std/rc/struct.Rc.html
+/// [arc]: ../../std/sync/struct.Arc.html
+/// [atomic data types]: ../sync/atomic/index.html
+/// [mutex]: ../../std/sync/struct.Mutex.html
+/// [rwlock]: ../../std/sync/struct.RwLock.html
+/// [unsafecell]: ../cell/struct.UnsafeCell.html
+/// [ub]: ../../reference.html#behavior-considered-undefined
+/// [transmute]: ../../std/mem/fn.transmute.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "sync"]
 #[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"]
@@ -314,29 +397,30 @@ fn default() -> $t<T> {
         )
 }
 
-/// `PhantomData<T>` allows you to describe that a type acts as if it stores a value of type `T`,
-/// even though it does not. This allows you to inform the compiler about certain safety properties
-/// of your code.
+/// Zero-sized type used to mark things that "act like" they own a `T`.
 ///
-/// For a more in-depth explanation of how to use `PhantomData<T>`, please see [the Nomicon].
+/// Adding a `PhantomData<T>` field to your type tells the compiler that your
+/// type acts as though it stores a value of type `T`, even though it doesn't
+/// really. This information is used when computing certain safety properties.
 ///
-/// [the Nomicon]: ../../nomicon/phantom-data.html
+/// For a more in-depth explanation of how to use `PhantomData<T>`, please see
+/// [the Nomicon](../../nomicon/phantom-data.html).
 ///
 /// # A ghastly note 👻👻👻
 ///
-/// Though they both have scary names, `PhantomData<T>` and 'phantom types' are related, but not
-/// identical. Phantom types are a more general concept that don't require `PhantomData<T>` to
-/// implement, but `PhantomData<T>` is the most common way to implement them in a correct manner.
+/// Though they both have scary names, `PhantomData` and 'phantom types' are
+/// related, but not identical. A phantom type parameter is simply a type
+/// parameter which is never used. In Rust, this often causes the compiler to
+/// complain, and the solution is to add a "dummy" use by way of `PhantomData`.
 ///
 /// # Examples
 ///
-/// ## Unused lifetime parameter
+/// ## Unused lifetime parameters
 ///
-/// Perhaps the most common time that `PhantomData` is required is
-/// with a struct that has an unused lifetime parameter, typically as
-/// part of some unsafe code. For example, here is a struct `Slice`
-/// that has two pointers of type `*const T`, presumably pointing into
-/// an array somewhere:
+/// Perhaps the most common use case for `PhantomData` is a struct that has an
+/// unused lifetime parameter, typically as part of some unsafe code. For
+/// example, here is a struct `Slice` that has two pointers of type `*const T`,
+/// presumably pointing into an array somewhere:
 ///
 /// ```ignore
 /// struct Slice<'a, T> {
@@ -350,7 +434,7 @@ fn default() -> $t<T> {
 /// intent is not expressed in the code, since there are no uses of
 /// the lifetime `'a` and hence it is not clear what data it applies
 /// to. We can correct this by telling the compiler to act *as if* the
-/// `Slice` struct contained a borrowed reference `&'a T`:
+/// `Slice` struct contained a reference `&'a T`:
 ///
 /// ```
 /// use std::marker::PhantomData;
@@ -359,29 +443,53 @@ fn default() -> $t<T> {
 /// struct Slice<'a, T: 'a> {
 ///     start: *const T,
 ///     end: *const T,
-///     phantom: PhantomData<&'a T>
+///     phantom: PhantomData<&'a T>,
 /// }
 /// ```
 ///
-/// This also in turn requires that we annotate `T:'a`, indicating
-/// that `T` is a type that can be borrowed for the lifetime `'a`.
+/// This also in turn requires the annotation `T: 'a`, indicating
+/// that any references in `T` are valid over the lifetime `'a`.
+///
+/// When initializing a `Slice` you simply provide the value
+/// `PhantomData` for the field `phantom`:
+///
+/// ```
+/// # #![allow(dead_code)]
+/// # use std::marker::PhantomData;
+/// # struct Slice<'a, T: 'a> {
+/// #     start: *const T,
+/// #     end: *const T,
+/// #     phantom: PhantomData<&'a T>,
+/// # }
+/// fn borrow_vec<'a, T>(vec: &'a Vec<T>) -> Slice<'a, T> {
+///     let ptr = vec.as_ptr();
+///     Slice {
+///         start: ptr,
+///         end: unsafe { ptr.offset(vec.len() as isize) },
+///         phantom: PhantomData,
+///     }
+/// }
+/// ```
 ///
 /// ## Unused type parameters
 ///
-/// It sometimes happens that there are unused type parameters that
+/// It sometimes happens that you have unused type parameters which
 /// indicate what type of data a struct is "tied" to, even though that
 /// data is not actually found in the struct itself. Here is an
-/// example where this arises when handling external resources over a
-/// foreign function interface. `PhantomData<T>` can prevent
-/// mismatches by enforcing types in the method implementations:
+/// example where this arises with [FFI]. The foreign interface uses
+/// handles of type `*mut ()` to refer to Rust values of different
+/// types. We track the Rust type using a phantom type parameter on
+/// the struct `ExternalResource` which wraps a handle.
+///
+/// [FFI]: ../../book/ffi.html
 ///
 /// ```
 /// # #![allow(dead_code)]
-/// # trait ResType { fn foo(&self); }
+/// # trait ResType { }
 /// # struct ParamType;
 /// # mod foreign_lib {
-/// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
-/// # pub fn do_stuff(_: *mut (), _: usize) {}
+/// #     pub fn new(_: usize) -> *mut () { 42 as *mut () }
+/// #     pub fn do_stuff(_: *mut (), _: usize) {}
 /// # }
 /// # fn convert_params(_: ParamType) -> usize { 42 }
 /// use std::marker::PhantomData;
@@ -408,21 +516,20 @@ fn default() -> $t<T> {
 /// }
 /// ```
 ///
-/// ## Indicating ownership
+/// ## Ownership and the drop check
 ///
-/// Adding a field of type `PhantomData<T>` also indicates that your
-/// struct owns data of type `T`. This in turn implies that when your
-/// struct is dropped, it may in turn drop one or more instances of
-/// the type `T`, though that may not be apparent from the other
-/// structure of the type itself. This is commonly necessary if the
-/// structure is using a raw pointer like `*mut T` whose referent
-/// may be dropped when the type is dropped, as a `*mut T` is
-/// otherwise not treated as owned.
+/// Adding a field of type `PhantomData<T>` indicates that your
+/// type owns data of type `T`. This in turn implies that when your
+/// type is dropped, it may drop one or more instances of the type
+/// `T`. This has bearing on the Rust compiler's [drop check]
+/// analysis.
 ///
 /// If your struct does not in fact *own* the data of type `T`, it is
 /// better to use a reference type, like `PhantomData<&'a T>`
 /// (ideally) or `PhantomData<*const T>` (if no lifetime applies), so
 /// as not to indicate ownership.
+///
+/// [drop check]: ../../nomicon/dropck.html
 #[lang = "phantom_data"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct PhantomData<T:?Sized>;
@@ -438,10 +545,13 @@ unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {}
 
 /// Types that can be reflected over.
 ///
-/// This trait is implemented for all types. Its purpose is to ensure
-/// that when you write a generic function that will employ
-/// reflection, that must be reflected (no pun intended) in the
-/// generic bounds of that function. Here is an example:
+/// By "reflection" we mean use of the [`Any`][any] trait, or related
+/// machinery such as [`TypeId`][typeid].
+///
+/// `Reflect` is implemented for all types. Its purpose is to ensure
+/// that when you write a generic function that will employ reflection,
+/// that must be reflected (no pun intended) in the generic bounds of
+/// that function.
 ///
 /// ```
 /// #![feature(reflect_marker)]
@@ -455,21 +565,24 @@ unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {}
 /// }
 /// ```
 ///
-/// Without the declaration `T: Reflect`, `foo` would not type check
-/// (note: as a matter of style, it would be preferable to write
-/// `T: Any`, because `T: Any` implies `T: Reflect` and `T: 'static`, but
-/// we use `Reflect` here to show how it works). The `Reflect` bound
-/// thus serves to alert `foo`'s caller to the fact that `foo` may
-/// behave differently depending on whether `T = u32` or not. In
-/// particular, thanks to the `Reflect` bound, callers know that a
-/// function declared like `fn bar<T>(...)` will always act in
-/// precisely the same way no matter what type `T` is supplied,
-/// because there are no bounds declared on `T`. (The ability for a
-/// caller to reason about what a function may do based solely on what
-/// generic bounds are declared is often called the ["parametricity
-/// property"][1].)
-///
-/// [1]: http://en.wikipedia.org/wiki/Parametricity
+/// Without the bound `T: Reflect`, `foo` would not typecheck. (As
+/// a matter of style, it would be preferable to write `T: Any`,
+/// because `T: Any` implies `T: Reflect` and `T: 'static`, but we
+/// use `Reflect` here for illustrative purposes.)
+///
+/// The `Reflect` bound serves to alert `foo`'s caller to the
+/// fact that `foo` may behave differently depending on whether
+/// `T` is `u32` or not. The ability for a caller to reason about what
+/// a function may do based solely on what generic bounds are declared
+/// is often called the "[parametricity property][param]". Despite the
+/// use of `Reflect`, Rust lacks true parametricity because a generic
+/// function can, at the very least, call [`mem::size_of`][size_of]
+/// without employing any trait bounds whatsoever.
+///
+/// [any]: ../any/trait.Any.html
+/// [typeid]: ../any/struct.TypeId.html
+/// [param]: http://en.wikipedia.org/wiki/Parametricity
+/// [size_of]: ../mem/fn.size_of.html
 #[rustc_reflect_like]
 #[unstable(feature = "reflect_marker",
            reason = "requires RFC and more experience",

src/librustc_bitflags/lib.rs

@@ -201,7 +201,7 @@ pub fn intersects(&self, other: $BitFlags) -> bool {
                 !(*self & other).is_empty()
             }
 
-            /// Returns `true` all of the flags in `other` are contained within `self`.
+            /// Returns `true` if all of the flags in `other` are contained within `self`.
             #[inline]
             pub fn contains(&self, other: $BitFlags) -> bool {
                 (*self & other) == other

src/librustc_driver/lib.rs

@@ -1054,7 +1054,8 @@ fn parse_crate_attrs<'a>(sess: &'a Session, input: &Input) -> PResult<'a, Vec<as
 /// The diagnostic emitter yielded to the procedure should be used for reporting
 /// errors of the compiler.
 pub fn monitor<F: FnOnce() + Send + 'static>(f: F) {
-    const STACK_SIZE: usize = 8 * 1024 * 1024; // 8MB
+    // Temporarily have stack size set to 16MB to deal with nom-using crates failing
+    const STACK_SIZE: usize = 16 * 1024 * 1024; // 16MB
 
     struct Sink(Arc<Mutex<Vec<u8>>>);
     impl Write for Sink {

src/librustc_typeck/check/compare_method.rs

@@ -38,7 +38,8 @@ pub fn compare_impl_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
                                      impl_m_span: Span,
                                      impl_m_body_id: ast::NodeId,
                                      trait_m: &ty::Method<'tcx>,
-                                     impl_trait_ref: &ty::TraitRef<'tcx>) {
+                                     impl_trait_ref: &ty::TraitRef<'tcx>,
+                                     trait_item_span: Option<Span>) {
     debug!("compare_impl_method(impl_trait_ref={:?})",
            impl_trait_ref);
 
@@ -97,14 +98,42 @@ pub fn compare_impl_method<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
     let num_impl_m_type_params = impl_m.generics.types.len();
     let num_trait_m_type_params = trait_m.generics.types.len();
     if num_impl_m_type_params != num_trait_m_type_params {
-        span_err!(tcx.sess, impl_m_span, E0049,
+        let impl_m_node_id = tcx.map.as_local_node_id(impl_m.def_id).unwrap();
+        let span = match tcx.map.expect_impl_item(impl_m_node_id).node {
+            ImplItemKind::Method(ref impl_m_sig, _) => {
+                if impl_m_sig.generics.is_parameterized() {
+                    impl_m_sig.generics.span
+                } else {
+                    impl_m_span
+                }
+            }
+            _ => bug!("{:?} is not a method", impl_m)
+        };
+
+        struct_span_err!(tcx.sess, span, E0049,
             "method `{}` has {} type parameter{} \
              but its trait declaration has {} type parameter{}",
             trait_m.name,
             num_impl_m_type_params,
             if num_impl_m_type_params == 1 {""} else {"s"},
             num_trait_m_type_params,
-            if num_trait_m_type_params == 1 {""} else {"s"});
+            if num_trait_m_type_params == 1 {""} else {"s"})
+            .span_label(trait_item_span.unwrap(),
+                        &format!("expected {}",
+                                 &if num_trait_m_type_params != 1 {
+                                     format!("{} type parameters",
+                                             num_trait_m_type_params)
+                                 } else {
+                                     format!("{} type parameter",
+                                             num_trait_m_type_params)
+                                 }))
+            .span_label(span, &format!("found {}",
+                                       &if num_impl_m_type_params != 1 {
+                                           format!("{} type parameters", num_impl_m_type_params)
+                                       } else {
+                                           format!("1 type parameter")
+                                       }))
+            .emit();
         return;
     }
 

src/librustc_typeck/check/mod.rs

@@ -1015,13 +1015,15 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
                         _ => span_bug!(impl_item.span, "non-method impl-item for method")
                     };
 
+                    let trait_span = tcx.map.span_if_local(ty_trait_item.def_id());
                     if let &ty::MethodTraitItem(ref trait_method) = ty_trait_item {
                         compare_impl_method(ccx,
                                             &impl_method,
                                             impl_item.span,
                                             body.id,
                                             &trait_method,
-                                            &impl_trait_ref);
+                                            &impl_trait_ref,
+                                            trait_span);
                     } else {
                         let mut err = struct_span_err!(tcx.sess, impl_item.span, E0324,
                                   "item `{}` is an associated method, \

src/libstd/env.rs

@@ -83,7 +83,7 @@ pub struct VarsOs { inner: os_imp::Env }
 /// environment variables of the current process.
 ///
 /// The returned iterator contains a snapshot of the process's environment
-/// variables at the time of this invocation, modifications to environment
+/// variables at the time of this invocation. Modifications to environment
 /// variables afterwards will not be reflected in the returned iterator.
 ///
 /// # Panics
@@ -112,7 +112,7 @@ pub fn vars() -> Vars {
 /// environment variables of the current process.
 ///
 /// The returned iterator contains a snapshot of the process's environment
-/// variables at the time of this invocation, modifications to environment
+/// variables at the time of this invocation. Modifications to environment
 /// variables afterwards will not be reflected in the returned iterator.
 ///
 /// # Examples

src/test/compile-fail/E0049.rs

@@ -9,13 +9,14 @@
 // except according to those terms.
 
 trait Foo {
-    fn foo<T: Default>(x: T) -> Self;
+    fn foo<T: Default>(x: T) -> Self; //~ NOTE expected 1 type parameter
 }
 
 struct Bar;
 
 impl Foo for Bar {
     fn foo(x: bool) -> Self { Bar } //~ ERROR E0049
+                                    //~| NOTE found 0 type parameters
 }
 
 fn main() {