From 27151017e987044a35ae45f8c9bd8530af9e5f47 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 21 Mar 2017 16:23:27 +0100
Subject: [PATCH 01/18] Add missing urls in ptr docs

---
 src/libstd/primitive_docs.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/libstd/primitive_docs.rs b/src/libstd/primitive_docs.rs
index 7d6d16f474845..ba14a3d6b47e7 100644
--- a/src/libstd/primitive_docs.rs
+++ b/src/libstd/primitive_docs.rs
@@ -183,9 +183,9 @@ mod prim_unit { }
 /// Working with raw pointers in Rust is uncommon,
 /// typically limited to a few patterns.
 ///
-/// Use the `null` function to create null pointers, and the `is_null` method
+/// Use the [`null`] function to create null pointers, and the [`is_null`] method
 /// of the `*const T` type  to check for null. The `*const T` type also defines
-/// the `offset` method, for pointer math.
+/// the [`offset`] method, for pointer math.
 ///
 /// # Common ways to create raw pointers
 ///
@@ -213,7 +213,7 @@ mod prim_unit { }
 ///
 /// ## 2. Consume a box (`Box<T>`).
 ///
-/// The `into_raw` function consumes a box and returns
+/// The [`into_raw`] function consumes a box and returns
 /// the raw pointer. It doesn't destroy `T` or deallocate any memory.
 ///
 /// ```
@@ -227,7 +227,7 @@ mod prim_unit { }
 /// }
 /// ```
 ///
-/// Note that here the call to `drop` is for clarity - it indicates
+/// Note that here the call to [`drop`] is for clarity - it indicates
 /// that we are done with the given value and it should be destroyed.
 ///
 /// ## 3. Get it from C.
@@ -255,6 +255,11 @@ mod prim_unit { }
 ///
 /// *[See also the `std::ptr` module](ptr/index.html).*
 ///
+/// [`null`]: ../std/ptr/fn.null.html
+/// [`is_null`]: ../std/primitive.pointer.html#method.is_null
+/// [`offset`]: ../std/primitive.pointer.html#method.offset
+/// [`into_raw`]: ../std/boxed/struct.Box.html#method.into_raw
+/// [`drop`]: ../std/mem/fn.drop.html
 #[stable(feature = "rust1", since = "1.0.0")]
 mod prim_pointer { }
 

From 4dc122580714a5f8859e993bf56a7228b0bcd7c1 Mon Sep 17 00:00:00 2001
From: Nick Sweeting <git@nicksweeting.com>
Date: Thu, 23 Mar 2017 13:17:21 -0400
Subject: [PATCH 02/18] Add helpful hint on io function for beginners

---
 src/libstd/io/mod.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 850885a8c0f3a..dda9d6bca7977 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -144,6 +144,16 @@
 //! # Ok(())
 //! # }
 //! ```
+//! Note that you cannot use the `?` operator in functions that do not return a `Result` (e.g. `main()`).
+//! Instead, you can `match` on the return value to catch any possible errors:
+//! 
+//! ```
+//! let mut input = String::new();
+//! match io::stdin().read_line(&mut input) {
+//!     Err(why) => panic!("Failed to read input: {}", why.description()),
+//!     Ok(_) => println!("You typed: {}", input.trim()),
+//! }
+//! ```
 //!
 //! And a very common source of output is standard output:
 //!

From 53d5082a2d08060ebca869cb8ee97c3ed3cf4ce9 Mon Sep 17 00:00:00 2001
From: Nick Sweeting <git@nicksweeting.com>
Date: Thu, 23 Mar 2017 13:42:39 -0400
Subject: [PATCH 03/18] requested changes

---
 src/libstd/io/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index dda9d6bca7977..60b211a746ff1 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -144,7 +144,8 @@
 //! # Ok(())
 //! # }
 //! ```
-//! Note that you cannot use the `?` operator in functions that do not return a `Result` (e.g. `main()`).
+//!
+//! Note that you cannot use the `?` operator in functions that do not return a `Result<T, E>` (e.g. `main`).
 //! Instead, you can `match` on the return value to catch any possible errors:
 //! 
 //! ```

From 04fbec1a0cb7467834bd264b80350b1cade8b4ca Mon Sep 17 00:00:00 2001
From: Nick Sweeting <git@nicksweeting.com>
Date: Thu, 23 Mar 2017 13:43:09 -0400
Subject: [PATCH 04/18] newline for breathing room

---
 src/libstd/io/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 60b211a746ff1..773b0964b4269 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -150,6 +150,7 @@
 //! 
 //! ```
 //! let mut input = String::new();
+//! 
 //! match io::stdin().read_line(&mut input) {
 //!     Err(why) => panic!("Failed to read input: {}", why.description()),
 //!     Ok(_) => println!("You typed: {}", input.trim()),

From 4806f01d7c1f35a1b6f675ff099b86ec6e6c1540 Mon Sep 17 00:00:00 2001
From: Nick Sweeting <git@nicksweeting.com>
Date: Mon, 27 Mar 2017 16:34:13 -0400
Subject: [PATCH 05/18] Fix tidy errors and simplify example

---
 src/libstd/io/mod.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 773b0964b4269..1b0c992ba0976 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -145,16 +145,14 @@
 //! # }
 //! ```
 //!
-//! Note that you cannot use the `?` operator in functions that do not return a `Result<T, E>` (e.g. `main`).
-//! Instead, you can `match` on the return value to catch any possible errors:
-//! 
+//! Note that you cannot use the `?` operator in functions that do not return
+//! a `Result<T, E>` (e.g. `main`). Instead, you can call `.unwrap()` or `match`
+//! on the return value to catch any possible errors:
+//!
 //! ```
 //! let mut input = String::new();
-//! 
-//! match io::stdin().read_line(&mut input) {
-//!     Err(why) => panic!("Failed to read input: {}", why.description()),
-//!     Ok(_) => println!("You typed: {}", input.trim()),
-//! }
+//!
+//! io::stdin().read_line(&mut input).unwrap();
 //! ```
 //!
 //! And a very common source of output is standard output:

From 756f2248f73d2ea2703a65855c52086a1262a290 Mon Sep 17 00:00:00 2001
From: projektir <oprojektir@gmail.com>
Date: Mon, 27 Mar 2017 23:55:03 -0400
Subject: [PATCH 06/18] Adding links for Atomics docs #29377

---
 src/libcore/sync/atomic.rs | 104 +++++++++++++++++++++++--------------
 1 file changed, 66 insertions(+), 38 deletions(-)

diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
index 743e3c41170a3..c3e7c9b7c989c 100644
--- a/src/libcore/sync/atomic.rs
+++ b/src/libcore/sync/atomic.rs
@@ -15,27 +15,37 @@
 //! types.
 //!
 //! This module defines atomic versions of a select number of primitive
-//! types, including `AtomicBool`, `AtomicIsize`, and `AtomicUsize`.
+//! types, including [`AtomicBool`], [`AtomicIsize`], and [`AtomicUsize`].
 //! Atomic types present operations that, when used correctly, synchronize
 //! updates between threads.
 //!
-//! Each method takes an `Ordering` which represents the strength of
+//! [`AtomicBool`]: struct.AtomicBool.html
+//! [`AtomicIsize`]: struct.AtomicIsize.html
+//! [`AtomicUsize`]: struct.AtomicUsize.html
+//!
+//! Each method takes an [`Ordering`] which represents the strength of
 //! the memory barrier for that operation. These orderings are the
 //! same as [LLVM atomic orderings][1]. For more information see the [nomicon][2].
 //!
+//! [`Ordering`]: enum.Ordering.html
+//!
 //! [1]: http://llvm.org/docs/LangRef.html#memory-model-for-concurrent-operations
 //! [2]: ../../../nomicon/atomics.html
 //!
-//! Atomic variables are safe to share between threads (they implement `Sync`)
+//! Atomic variables are safe to share between threads (they implement [`Sync`])
 //! but they do not themselves provide the mechanism for sharing and follow the
 //! [threading model](../../../std/thread/index.html#the-threading-model) of rust.
-//! The most common way to share an atomic variable is to put it into an `Arc` (an
+//! The most common way to share an atomic variable is to put it into an [`Arc`][arc] (an
 //! atomically-reference-counted shared pointer).
 //!
+//! [`Sync`]: ../../marker/trait.Sync.html
+//! [arc]: ../struct.Arc.html
+//!
 //! Most atomic types may be stored in static variables, initialized using
-//! the provided static initializers like `ATOMIC_BOOL_INIT`. Atomic statics
+//! the provided static initializers like [`ATOMIC_BOOL_INIT`]. Atomic statics
 //! are often used for lazy global initialization.
 //!
+//! [`ATOMIC_BOOL_INIT`]: constant.ATOMIC_BOOL_INIT.html
 //!
 //! # Examples
 //!
@@ -149,21 +159,26 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
 #[derive(Copy, Clone, Debug)]
 pub enum Ordering {
     /// No ordering constraints, only atomic operations. Corresponds to LLVM's
-    /// `Monotonic` ordering.
+    /// [`Monotonic`][1] ordering.
+    /// [1]: http://llvm.org/docs/Atomics.html#monotonic
     #[stable(feature = "rust1", since = "1.0.0")]
     Relaxed,
     /// When coupled with a store, all previous writes become visible
-    /// to the other threads that perform a load with `Acquire` ordering
+    /// to the other threads that perform a load with [`Acquire`][1] ordering
     /// on the same value.
+    /// [1]: http://llvm.org/docs/Atomics.html#acquire
     #[stable(feature = "rust1", since = "1.0.0")]
     Release,
     /// When coupled with a load, all subsequent loads will see data
-    /// written before a store with `Release` ordering on the same value
+    /// written before a store with [`Release`][1] ordering on the same value
     /// in other threads.
+    /// [1]: http://llvm.org/docs/Atomics.html#release
     #[stable(feature = "rust1", since = "1.0.0")]
     Acquire,
-    /// When coupled with a load, uses `Acquire` ordering, and with a store
-    /// `Release` ordering.
+    /// When coupled with a load, uses [`Acquire`][1] ordering, and with a store
+    /// [`Release`][2] ordering.
+    /// [1]: http://llvm.org/docs/Atomics.html#acquire
+    /// [2]: http://llvm.org/docs/Atomics.html#release
     #[stable(feature = "rust1", since = "1.0.0")]
     AcqRel,
     /// Like `AcqRel` with the additional guarantee that all threads see all
@@ -176,7 +191,8 @@ pub enum Ordering {
     __Nonexhaustive,
 }
 
-/// An `AtomicBool` initialized to `false`.
+/// An [`AtomicBool`] initialized to `false`.
+/// [`AtomicBool`]: struct.AtomicBool.html
 #[cfg(target_has_atomic = "8")]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub const ATOMIC_BOOL_INIT: AtomicBool = AtomicBool::new(false);
@@ -241,7 +257,7 @@ impl AtomicBool {
 
     /// Loads a value from the bool.
     ///
-    /// `load` takes an [`Ordering`] argument which describes the memory ordering
+    /// `load()` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// # Panics
@@ -250,7 +266,7 @@ impl AtomicBool {
     ///
     /// [`Ordering`]: enum.Ordering.html
     /// [`Release`]: enum.Ordering.html#variant.Release
-    /// [`AcqRel`]: enum.Ordering.html#variant.Release
+    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
     ///
     /// # Examples
     ///
@@ -269,7 +285,7 @@ impl AtomicBool {
 
     /// Stores a value into the bool.
     ///
-    /// `store` takes an [`Ordering`] argument which describes the memory ordering
+    /// `store()` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -287,7 +303,10 @@ impl AtomicBool {
     ///
     /// # Panics
     ///
-    /// Panics if `order` is `Acquire` or `AcqRel`.
+    /// Panics if `order` is [`Acquire`] or [`AcqRel`].
+    ///
+    /// [`Acquire`]: enum.Ordering.html#variant.Acquire
+    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn store(&self, val: bool, order: Ordering) {
@@ -298,7 +317,7 @@ impl AtomicBool {
 
     /// Stores a value into the bool, returning the old value.
     ///
-    /// `swap` takes an [`Ordering`] argument which describes the memory ordering
+    /// `swap()` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -324,7 +343,7 @@ impl AtomicBool {
     /// The return value is always the previous value. If it is equal to `current`, then the value
     /// was updated.
     ///
-    /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
+    /// `compare_and_swap()` also takes an [`Ordering`] argument which describes the memory
     /// ordering of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -356,7 +375,7 @@ impl AtomicBool {
     /// The return value is a result indicating whether the new value was written and containing
     /// the previous value. On success this value is guaranteed to be equal to `current`.
     ///
-    /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange()` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if the
     /// operation succeeds while the second describes the required ordering when the
     /// operation fails. The failure ordering can't be [`Release`] or [`AcqRel`] and must
@@ -404,17 +423,18 @@ impl AtomicBool {
 
     /// Stores a value into the `bool` if the current value is the same as the `current` value.
     ///
-    /// Unlike `compare_exchange`, this function is allowed to spuriously fail even when the
+    /// Unlike [`compare_exchange()`], this function is allowed to spuriously fail even when the
     /// comparison succeeds, which can result in more efficient code on some platforms. The
     /// return value is a result indicating whether the new value was written and containing the
     /// previous value.
     ///
-    /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange_weak()` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if the operation
     /// succeeds while the second describes the required ordering when the operation fails. The
     /// failure ordering can't be [`Release`] or [`AcqRel`] and must be equivalent or
     /// weaker than the success ordering.
     ///
+    /// [`compare_exchange()`]: #method.compare_exchange
     /// [`Ordering`]: enum.Ordering.html
     /// [`Release`]: enum.Ordering.html#variant.Release
     /// [`AcqRel`]: enum.Ordering.html#variant.Release
@@ -645,7 +665,7 @@ impl<T> AtomicPtr<T> {
 
     /// Loads a value from the pointer.
     ///
-    /// `load` takes an [`Ordering`] argument which describes the memory ordering
+    /// `load()` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// # Panics
@@ -674,7 +694,7 @@ impl<T> AtomicPtr<T> {
 
     /// Stores a value into the pointer.
     ///
-    /// `store` takes an [`Ordering`] argument which describes the memory ordering
+    /// `store()` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -694,7 +714,11 @@ impl<T> AtomicPtr<T> {
     ///
     /// # Panics
     ///
-    /// Panics if `order` is `Acquire` or `AcqRel`.
+    /// Panics if `order` is [`Acquire`] or [`AcqRel`].
+    ///
+    /// [`Acquire`]: enum.Ordering.html#variant.Acquire
+    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
+    ///
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn store(&self, ptr: *mut T, order: Ordering) {
@@ -705,7 +729,7 @@ impl<T> AtomicPtr<T> {
 
     /// Stores a value into the pointer, returning the old value.
     ///
-    /// `swap` takes an [`Ordering`] argument which describes the memory ordering
+    /// `swap()` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -733,7 +757,7 @@ impl<T> AtomicPtr<T> {
     /// The return value is always the previous value. If it is equal to `current`, then the value
     /// was updated.
     ///
-    /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
+    /// `compare_and_swap()` also takes an [`Ordering`] argument which describes the memory
     /// ordering of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -765,7 +789,7 @@ impl<T> AtomicPtr<T> {
     /// The return value is a result indicating whether the new value was written and containing
     /// the previous value. On success this value is guaranteed to be equal to `current`.
     ///
-    /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange()` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if
     /// the operation succeeds while the second describes the required ordering when
     /// the operation fails. The failure ordering can't be [`Release`] or [`AcqRel`]
@@ -812,18 +836,18 @@ impl<T> AtomicPtr<T> {
 
     /// Stores a value into the pointer if the current value is the same as the `current` value.
     ///
-    /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even when the
+    /// Unlike [`compare_exchange()`], this function is allowed to spuriously fail even when the
     /// comparison succeeds, which can result in more efficient code on some platforms. The
     /// return value is a result indicating whether the new value was written and containing the
     /// previous value.
     ///
-    /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange_weak()` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if the operation
     /// succeeds while the second describes the required ordering when the operation fails. The
     /// failure ordering can't be [`Release`] or [`AcqRel`] and must be equivalent or
     /// weaker than the success ordering.
     ///
-    /// [`compare_exchange`]: #method.compare_exchange
+    /// [`compare_exchange()`]: #method.compare_exchange
     /// [`Ordering`]: enum.Ordering.html
     /// [`Release`]: enum.Ordering.html#variant.Release
     /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
@@ -962,7 +986,7 @@ macro_rules! atomic_int {
 
             /// Loads a value from the atomic integer.
             ///
-            /// `load` takes an [`Ordering`] argument which describes the memory ordering of this
+            /// `load()` takes an [`Ordering`] argument which describes the memory ordering of this
             /// operation.
             ///
             /// # Panics
@@ -990,7 +1014,7 @@ macro_rules! atomic_int {
 
             /// Stores a value into the atomic integer.
             ///
-            /// `store` takes an [`Ordering`] argument which describes the memory ordering of this
+            /// `store()` takes an [`Ordering`] argument which describes the memory ordering of this
             /// operation.
             ///
             /// [`Ordering`]: enum.Ordering.html
@@ -1008,7 +1032,11 @@ macro_rules! atomic_int {
             ///
             /// # Panics
             ///
-            /// Panics if `order` is `Acquire` or `AcqRel`.
+            /// Panics if `order` is [`Acquire`] or [`AcqRel`].
+            ///
+            /// [`Acquire`]: enum.Ordering.html#variant.Acquire
+            /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
+            ///
             #[inline]
             #[$stable]
             pub fn store(&self, val: $int_type, order: Ordering) {
@@ -1017,7 +1045,7 @@ macro_rules! atomic_int {
 
             /// Stores a value into the atomic integer, returning the old value.
             ///
-            /// `swap` takes an [`Ordering`] argument which describes the memory ordering of this
+            /// `swap()` takes an [`Ordering`] argument which describes the memory ordering of this
             /// operation.
             ///
             /// [`Ordering`]: enum.Ordering.html
@@ -1043,7 +1071,7 @@ macro_rules! atomic_int {
             /// The return value is always the previous value. If it is equal to `current`, then the
             /// value was updated.
             ///
-            /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
+            /// `compare_and_swap()` also takes an [`Ordering`] argument which describes the memory
             /// ordering of this operation.
             ///
             /// [`Ordering`]: enum.Ordering.html
@@ -1083,7 +1111,7 @@ macro_rules! atomic_int {
             /// containing the previous value. On success this value is guaranteed to be equal to
             /// `current`.
             ///
-            /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
+            /// `compare_exchange()` takes two [`Ordering`] arguments to describe the memory
             /// ordering of this operation. The first describes the required ordering if
             /// the operation succeeds while the second describes the required ordering when
             /// the operation fails. The failure ordering can't be [`Release`] or [`AcqRel`] and
@@ -1125,18 +1153,18 @@ macro_rules! atomic_int {
             /// Stores a value into the atomic integer if the current value is the same as the
             /// `current` value.
             ///
-            /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even
+            /// Unlike [`compare_exchange()`], this function is allowed to spuriously fail even
             /// when the comparison succeeds, which can result in more efficient code on some
             /// platforms. The return value is a result indicating whether the new value was
             /// written and containing the previous value.
             ///
-            /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
+            /// `compare_exchange_weak()` takes two [`Ordering`] arguments to describe the memory
             /// ordering of this operation. The first describes the required ordering if the
             /// operation succeeds while the second describes the required ordering when the
             /// operation fails. The failure ordering can't be [`Release`] or [`AcqRel`] and
             /// must be equivalent or weaker than the success ordering.
             ///
-            /// [`compare_exchange`]: #method.compare_exchange
+            /// [`compare_exchange()`]: #method.compare_exchange
             /// [`Ordering`]: enum.Ordering.html
             /// [`Release`]: enum.Ordering.html#variant.Release
             /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel

From cd2ec7eded8d65b88b4c2fdb26efe1b3c505bd6f Mon Sep 17 00:00:00 2001
From: Nick Sweeting <git@nicksweeting.com>
Date: Tue, 28 Mar 2017 13:27:46 -0400
Subject: [PATCH 07/18] add missing import

---
 src/libstd/io/mod.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 1b0c992ba0976..32ead78f6cd58 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -150,6 +150,8 @@
 //! on the return value to catch any possible errors:
 //!
 //! ```
+//! use std::io;
+//!
 //! let mut input = String::new();
 //!
 //! io::stdin().read_line(&mut input).unwrap();

From 11ce5b72a21718f6d49b5f40b71ea0f53b8ea4bc Mon Sep 17 00:00:00 2001
From: topecongiro <seuchida@gmail.com>
Date: Wed, 22 Mar 2017 16:17:15 +0900
Subject: [PATCH 08/18] Make overlapping_inherent_impls lint a hard error

---
 src/librustc_lint/lib.rs                                     | 5 +----
 src/librustc_typeck/coherence/inherent_impls.rs              | 1 -
 src/librustc_typeck/diagnostics.rs                           | 1 +
 .../coherence-overlapping-inherent-impl-trait.rs             | 2 --
 src/test/compile-fail/inherent-overlap.rs                    | 3 ---
 5 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs
index 05dbbc0987025..8d759d89135ac 100644
--- a/src/librustc_lint/lib.rs
+++ b/src/librustc_lint/lib.rs
@@ -196,10 +196,6 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
             id: LintId::of(SUPER_OR_SELF_IN_GLOBAL_PATH),
             reference: "issue #36888 <https://github.com/rust-lang/rust/issues/36888>",
         },
-        FutureIncompatibleInfo {
-            id: LintId::of(OVERLAPPING_INHERENT_IMPLS),
-            reference: "issue #36889 <https://github.com/rust-lang/rust/issues/36889>",
-        },
         FutureIncompatibleInfo {
             id: LintId::of(ILLEGAL_FLOATING_POINT_CONSTANT_PATTERN),
             reference: "issue #36890 <https://github.com/rust-lang/rust/issues/36890>",
@@ -263,4 +259,5 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
     store.register_removed("drop_with_repr_extern", "drop flags have been removed");
     store.register_removed("transmute_from_fn_item_types",
         "always cast functions before transmuting them");
+    store.register_removed("overlapping_inherent_impls", "converted into hard error, see #36889");
 }
diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs
index 3a39df505eb07..dc4bd7733fc21 100644
--- a/src/librustc_typeck/coherence/inherent_impls.rs
+++ b/src/librustc_typeck/coherence/inherent_impls.rs
@@ -322,4 +322,3 @@ impl<'a, 'tcx> InherentCollect<'a, 'tcx> {
         }
     }
 }
-
diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs
index bd6129eb5bee3..fb951fd20e564 100644
--- a/src/librustc_typeck/diagnostics.rs
+++ b/src/librustc_typeck/diagnostics.rs
@@ -4212,4 +4212,5 @@ register_diagnostics! {
            // but `{}` was found in the type `{}`
     E0567, // auto traits can not have type parameters
     E0568, // auto-traits can not have predicates,
+    E0592, // duplicate definitions with name `{}`
 }
diff --git a/src/test/compile-fail/coherence-overlapping-inherent-impl-trait.rs b/src/test/compile-fail/coherence-overlapping-inherent-impl-trait.rs
index 08e8605e91773..158d3606104a9 100644
--- a/src/test/compile-fail/coherence-overlapping-inherent-impl-trait.rs
+++ b/src/test/compile-fail/coherence-overlapping-inherent-impl-trait.rs
@@ -9,10 +9,8 @@
 // except according to those terms.
 
 #![allow(dead_code)]
-#![deny(overlapping_inherent_impls)]
 
 trait C {}
 impl C { fn f() {} } //~ ERROR duplicate definitions with name `f`
-//~^ WARN: this was previously accepted
 impl C { fn f() {} }
 fn main() { }
diff --git a/src/test/compile-fail/inherent-overlap.rs b/src/test/compile-fail/inherent-overlap.rs
index 00d41244639f5..18e77ddfd2c5b 100644
--- a/src/test/compile-fail/inherent-overlap.rs
+++ b/src/test/compile-fail/inherent-overlap.rs
@@ -17,7 +17,6 @@ struct Foo;
 
 impl Foo {
     fn id() {} //~ ERROR duplicate definitions
-    //~^ WARN previously accepted
 }
 
 impl Foo {
@@ -28,7 +27,6 @@ struct Bar<T>(T);
 
 impl<T> Bar<T> {
     fn bar(&self) {} //~ ERROR duplicate definitions
-    //~^ WARN previously accepted
 }
 
 impl Bar<u32> {
@@ -39,7 +37,6 @@ struct Baz<T>(T);
 
 impl<T: Copy> Baz<T> {
     fn baz(&self) {} //~ ERROR duplicate definitions
-    //~^ WARN previously accepted
 }
 
 impl<T> Baz<Vec<T>> {

From 4ea03c876ba864946ed50fde7788cfe2383027f1 Mon Sep 17 00:00:00 2001
From: projektir <oprojektir@gmail.com>
Date: Wed, 29 Mar 2017 00:52:16 -0400
Subject: [PATCH 09/18] Fixing formatting issues #29377

---
 src/libcore/sync/atomic.rs | 80 ++++++++++++++++++++------------------
 1 file changed, 42 insertions(+), 38 deletions(-)

diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
index c3e7c9b7c989c..ae47e6fdfa928 100644
--- a/src/libcore/sync/atomic.rs
+++ b/src/libcore/sync/atomic.rs
@@ -39,7 +39,7 @@
 //! atomically-reference-counted shared pointer).
 //!
 //! [`Sync`]: ../../marker/trait.Sync.html
-//! [arc]: ../struct.Arc.html
+//! [arc]: ../../../std/sync/struct.Arc.html
 //!
 //! Most atomic types may be stored in static variables, initialized using
 //! the provided static initializers like [`ATOMIC_BOOL_INIT`]. Atomic statics
@@ -158,27 +158,32 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Copy, Clone, Debug)]
 pub enum Ordering {
-    /// No ordering constraints, only atomic operations. Corresponds to LLVM's
-    /// [`Monotonic`][1] ordering.
-    /// [1]: http://llvm.org/docs/Atomics.html#monotonic
+    /// No ordering constraints, only atomic operations.
+    ///
+    /// Corresponds to LLVM's [`Monotonic`] ordering.
+    ///
+    /// [`Monotonic`]: http://llvm.org/docs/Atomics.html#monotonic
     #[stable(feature = "rust1", since = "1.0.0")]
     Relaxed,
     /// When coupled with a store, all previous writes become visible
-    /// to the other threads that perform a load with [`Acquire`][1] ordering
+    /// to the other threads that perform a load with [`Acquire`] ordering
     /// on the same value.
-    /// [1]: http://llvm.org/docs/Atomics.html#acquire
+    ///
+    /// [`Acquire`]: http://llvm.org/docs/Atomics.html#acquire
     #[stable(feature = "rust1", since = "1.0.0")]
     Release,
     /// When coupled with a load, all subsequent loads will see data
-    /// written before a store with [`Release`][1] ordering on the same value
+    /// written before a store with [`Release`] ordering on the same value
     /// in other threads.
-    /// [1]: http://llvm.org/docs/Atomics.html#release
+    ///
+    /// [`Release`]: http://llvm.org/docs/Atomics.html#release
     #[stable(feature = "rust1", since = "1.0.0")]
     Acquire,
-    /// When coupled with a load, uses [`Acquire`][1] ordering, and with a store
-    /// [`Release`][2] ordering.
-    /// [1]: http://llvm.org/docs/Atomics.html#acquire
-    /// [2]: http://llvm.org/docs/Atomics.html#release
+    /// When coupled with a load, uses [`Acquire`] ordering, and with a store
+    /// [`Release`] ordering.
+    ///
+    /// [`Acquire`]: http://llvm.org/docs/Atomics.html#acquire
+    /// [`Release`]: http://llvm.org/docs/Atomics.html#release
     #[stable(feature = "rust1", since = "1.0.0")]
     AcqRel,
     /// Like `AcqRel` with the additional guarantee that all threads see all
@@ -192,6 +197,7 @@ pub enum Ordering {
 }
 
 /// An [`AtomicBool`] initialized to `false`.
+///
 /// [`AtomicBool`]: struct.AtomicBool.html
 #[cfg(target_has_atomic = "8")]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -257,7 +263,7 @@ impl AtomicBool {
 
     /// Loads a value from the bool.
     ///
-    /// `load()` takes an [`Ordering`] argument which describes the memory ordering
+    /// `load` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// # Panics
@@ -285,7 +291,7 @@ impl AtomicBool {
 
     /// Stores a value into the bool.
     ///
-    /// `store()` takes an [`Ordering`] argument which describes the memory ordering
+    /// `store` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -317,7 +323,7 @@ impl AtomicBool {
 
     /// Stores a value into the bool, returning the old value.
     ///
-    /// `swap()` takes an [`Ordering`] argument which describes the memory ordering
+    /// `swap` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -343,7 +349,7 @@ impl AtomicBool {
     /// The return value is always the previous value. If it is equal to `current`, then the value
     /// was updated.
     ///
-    /// `compare_and_swap()` also takes an [`Ordering`] argument which describes the memory
+    /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
     /// ordering of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -375,7 +381,7 @@ impl AtomicBool {
     /// The return value is a result indicating whether the new value was written and containing
     /// the previous value. On success this value is guaranteed to be equal to `current`.
     ///
-    /// `compare_exchange()` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if the
     /// operation succeeds while the second describes the required ordering when the
     /// operation fails. The failure ordering can't be [`Release`] or [`AcqRel`] and must
@@ -423,18 +429,18 @@ impl AtomicBool {
 
     /// Stores a value into the `bool` if the current value is the same as the `current` value.
     ///
-    /// Unlike [`compare_exchange()`], this function is allowed to spuriously fail even when the
+    /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even when the
     /// comparison succeeds, which can result in more efficient code on some platforms. The
     /// return value is a result indicating whether the new value was written and containing the
     /// previous value.
     ///
-    /// `compare_exchange_weak()` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if the operation
     /// succeeds while the second describes the required ordering when the operation fails. The
     /// failure ordering can't be [`Release`] or [`AcqRel`] and must be equivalent or
     /// weaker than the success ordering.
     ///
-    /// [`compare_exchange()`]: #method.compare_exchange
+    /// [`compare_exchange`]: #method.compare_exchange
     /// [`Ordering`]: enum.Ordering.html
     /// [`Release`]: enum.Ordering.html#variant.Release
     /// [`AcqRel`]: enum.Ordering.html#variant.Release
@@ -665,7 +671,7 @@ impl<T> AtomicPtr<T> {
 
     /// Loads a value from the pointer.
     ///
-    /// `load()` takes an [`Ordering`] argument which describes the memory ordering
+    /// `load` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// # Panics
@@ -694,7 +700,7 @@ impl<T> AtomicPtr<T> {
 
     /// Stores a value into the pointer.
     ///
-    /// `store()` takes an [`Ordering`] argument which describes the memory ordering
+    /// `store` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -718,7 +724,6 @@ impl<T> AtomicPtr<T> {
     ///
     /// [`Acquire`]: enum.Ordering.html#variant.Acquire
     /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
-    ///
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn store(&self, ptr: *mut T, order: Ordering) {
@@ -729,7 +734,7 @@ impl<T> AtomicPtr<T> {
 
     /// Stores a value into the pointer, returning the old value.
     ///
-    /// `swap()` takes an [`Ordering`] argument which describes the memory ordering
+    /// `swap` takes an [`Ordering`] argument which describes the memory ordering
     /// of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -757,7 +762,7 @@ impl<T> AtomicPtr<T> {
     /// The return value is always the previous value. If it is equal to `current`, then the value
     /// was updated.
     ///
-    /// `compare_and_swap()` also takes an [`Ordering`] argument which describes the memory
+    /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
     /// ordering of this operation.
     ///
     /// [`Ordering`]: enum.Ordering.html
@@ -789,7 +794,7 @@ impl<T> AtomicPtr<T> {
     /// The return value is a result indicating whether the new value was written and containing
     /// the previous value. On success this value is guaranteed to be equal to `current`.
     ///
-    /// `compare_exchange()` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if
     /// the operation succeeds while the second describes the required ordering when
     /// the operation fails. The failure ordering can't be [`Release`] or [`AcqRel`]
@@ -836,18 +841,18 @@ impl<T> AtomicPtr<T> {
 
     /// Stores a value into the pointer if the current value is the same as the `current` value.
     ///
-    /// Unlike [`compare_exchange()`], this function is allowed to spuriously fail even when the
+    /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even when the
     /// comparison succeeds, which can result in more efficient code on some platforms. The
     /// return value is a result indicating whether the new value was written and containing the
     /// previous value.
     ///
-    /// `compare_exchange_weak()` takes two [`Ordering`] arguments to describe the memory
+    /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
     /// ordering of this operation. The first describes the required ordering if the operation
     /// succeeds while the second describes the required ordering when the operation fails. The
     /// failure ordering can't be [`Release`] or [`AcqRel`] and must be equivalent or
     /// weaker than the success ordering.
     ///
-    /// [`compare_exchange()`]: #method.compare_exchange
+    /// [`compare_exchange`]: #method.compare_exchange
     /// [`Ordering`]: enum.Ordering.html
     /// [`Release`]: enum.Ordering.html#variant.Release
     /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
@@ -986,7 +991,7 @@ macro_rules! atomic_int {
 
             /// Loads a value from the atomic integer.
             ///
-            /// `load()` takes an [`Ordering`] argument which describes the memory ordering of this
+            /// `load` takes an [`Ordering`] argument which describes the memory ordering of this
             /// operation.
             ///
             /// # Panics
@@ -1014,7 +1019,7 @@ macro_rules! atomic_int {
 
             /// Stores a value into the atomic integer.
             ///
-            /// `store()` takes an [`Ordering`] argument which describes the memory ordering of this
+            /// `store` takes an [`Ordering`] argument which describes the memory ordering of this
             /// operation.
             ///
             /// [`Ordering`]: enum.Ordering.html
@@ -1036,7 +1041,6 @@ macro_rules! atomic_int {
             ///
             /// [`Acquire`]: enum.Ordering.html#variant.Acquire
             /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel
-            ///
             #[inline]
             #[$stable]
             pub fn store(&self, val: $int_type, order: Ordering) {
@@ -1045,7 +1049,7 @@ macro_rules! atomic_int {
 
             /// Stores a value into the atomic integer, returning the old value.
             ///
-            /// `swap()` takes an [`Ordering`] argument which describes the memory ordering of this
+            /// `swap` takes an [`Ordering`] argument which describes the memory ordering of this
             /// operation.
             ///
             /// [`Ordering`]: enum.Ordering.html
@@ -1071,7 +1075,7 @@ macro_rules! atomic_int {
             /// The return value is always the previous value. If it is equal to `current`, then the
             /// value was updated.
             ///
-            /// `compare_and_swap()` also takes an [`Ordering`] argument which describes the memory
+            /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory
             /// ordering of this operation.
             ///
             /// [`Ordering`]: enum.Ordering.html
@@ -1111,7 +1115,7 @@ macro_rules! atomic_int {
             /// containing the previous value. On success this value is guaranteed to be equal to
             /// `current`.
             ///
-            /// `compare_exchange()` takes two [`Ordering`] arguments to describe the memory
+            /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory
             /// ordering of this operation. The first describes the required ordering if
             /// the operation succeeds while the second describes the required ordering when
             /// the operation fails. The failure ordering can't be [`Release`] or [`AcqRel`] and
@@ -1153,18 +1157,18 @@ macro_rules! atomic_int {
             /// Stores a value into the atomic integer if the current value is the same as the
             /// `current` value.
             ///
-            /// Unlike [`compare_exchange()`], this function is allowed to spuriously fail even
+            /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even
             /// when the comparison succeeds, which can result in more efficient code on some
             /// platforms. The return value is a result indicating whether the new value was
             /// written and containing the previous value.
             ///
-            /// `compare_exchange_weak()` takes two [`Ordering`] arguments to describe the memory
+            /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory
             /// ordering of this operation. The first describes the required ordering if the
             /// operation succeeds while the second describes the required ordering when the
             /// operation fails. The failure ordering can't be [`Release`] or [`AcqRel`] and
             /// must be equivalent or weaker than the success ordering.
             ///
-            /// [`compare_exchange()`]: #method.compare_exchange
+            /// [`compare_exchange`]: #method.compare_exchange
             /// [`Ordering`]: enum.Ordering.html
             /// [`Release`]: enum.Ordering.html#variant.Release
             /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel

From 9d4b486b845c7d04691801f1151219b41b7c327b Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 15:36:50 -0400
Subject: [PATCH 10/18] Modify Lines' description

---
 src/libcore/str/mod.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 857eeb26af078..e995b59a14505 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1161,9 +1161,13 @@ generate_pattern_iterators! {
     delegate double ended;
 }
 
-/// Created with the method [`lines`].
+/// An iterator over the lines of a string, as string slices.
 ///
-/// [`lines`]: ../../std/primitive.str.html#method.lines
+/// This struct is created with the [`lines()`] method on [`str`].
+/// See its documentation for more.
+///
+/// [`lines()`]: ../../std/primitive.str.html#method.lines
+/// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Clone, Debug)]
 pub struct Lines<'a>(Map<SplitTerminator<'a, char>, LinesAnyMap>);

From 0f5cf54246f7a68a8fc18ee41dffc7cdf866e19c Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 15:40:05 -0400
Subject: [PATCH 11/18] Modify Bytes' description

---
 src/libcore/str/mod.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index e995b59a14505..4556d41dd0a5a 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -625,12 +625,13 @@ impl<'a> CharIndices<'a> {
     }
 }
 
-/// External iterator for a string's bytes.
-/// Use with the `std::iter` module.
+/// An iterator over the bytes of a string slice.
 ///
-/// Created with the method [`bytes`].
+/// This struct is created by the [`bytes()`] method on [`str`].
+/// See its documentation for more.
 ///
-/// [`bytes`]: ../../std/primitive.str.html#method.bytes
+/// [`bytes()`]: ../../std/primitive.str.html#method.bytes
+/// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Clone, Debug)]
 pub struct Bytes<'a>(Cloned<slice::Iter<'a, u8>>);

From 41e04985867e04b2be7b7fbd90864e5d9b3a276f Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 15:46:41 -0400
Subject: [PATCH 12/18] Modify CharIndices' description

---
 src/libcore/str/mod.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 4556d41dd0a5a..4720c965c57ce 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -553,7 +553,15 @@ impl<'a> Chars<'a> {
     }
 }
 
-/// Iterator for a string's characters and their byte offsets.
+/// An iterator over the [`char`]s of a string slice, and their positions.
+///
+/// [`char`]: ../../std/primitive.char.html
+///
+/// This struct is created by the [`char_indices()`] method on [`str`].
+/// See its documentation for more.
+///
+/// [`char_indices()`]: ../../std/primitive.str.html#method.char_indices
+/// [`str`]: ../../std/primitive.str.html
 #[derive(Clone, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct CharIndices<'a> {

From 17b4884d3c3d88af7f43d5fca32fd8f48d75669b Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 15:51:49 -0400
Subject: [PATCH 13/18] Modify Chars' description

---
 src/libcore/str/mod.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 4720c965c57ce..11d52e3c15bc3 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -369,11 +369,15 @@ impl fmt::Display for Utf8Error {
 Section: Iterators
 */
 
-/// Iterator for the char (representing *Unicode Scalar Values*) of a string.
+/// An iterator over the [`char`]s of a string slice.
 ///
-/// Created with the method [`chars`].
+/// [`char`]: ../../std/primitive.char.html
+///
+/// This struct is created by the [`chars()`] method on [`str`].
+/// See its documentation for more.
 ///
-/// [`chars`]: ../../std/primitive.str.html#method.chars
+/// [`chars()`]: ../../std/primitive.str.html#method.chars
+/// [`str`]: ../../std/primitive.str.html
 #[derive(Clone, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Chars<'a> {

From 5d14ccbc96923607f6ab00810817885ee0939486 Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 16:35:19 -0400
Subject: [PATCH 14/18] Modify EncodeUtf16's description

---
 src/libcollections/str.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 219e818f7d738..aee6861a09f40 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -133,9 +133,15 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
     }
 }
 
-/// External iterator for a string's UTF-16 code units.
+/// An iterator of [`u16`] over the string encoded as UTF-16.
 ///
-/// For use with the `std::iter` module.
+/// [`u16`]: ../../std/primitive.u16.html
+///
+/// This struct is created by the [`encode_utf16()`] method on [`str`].
+/// See its documentation for more.
+///
+/// [`encode_utf16()`]: ../../std/primitive.str.html#method.encode_utf16
+/// [`str`]: ../../std/primitive.str.html
 #[derive(Clone)]
 #[stable(feature = "encode_utf16", since = "1.8.0")]
 pub struct EncodeUtf16<'a> {

From a4a7166fd585802e9644ae9b4aa3e63861d11d3e Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 16:36:06 -0400
Subject: [PATCH 15/18] Modify SplitWhitespace's description

---
 src/libstd_unicode/u_str.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/libstd_unicode/u_str.rs b/src/libstd_unicode/u_str.rs
index 3c02ea82d2a11..fd309e822a0e5 100644
--- a/src/libstd_unicode/u_str.rs
+++ b/src/libstd_unicode/u_str.rs
@@ -17,8 +17,13 @@ use core::char;
 use core::iter::{Filter, FusedIterator};
 use core::str::Split;
 
-/// An iterator over the non-whitespace substrings of a string,
-/// separated by any amount of whitespace.
+/// An iterator over sub-slices of the original string slice.
+///
+/// This struct is created by the [`split_whitespace()`] method on [`str`].
+/// See its documentation for more.
+///
+/// [`split_whitespace()`]: ../../std/primitive.str.html#method.split_whitespace
+/// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "split_whitespace", since = "1.1.0")]
 pub struct SplitWhitespace<'a> {
     inner: Filter<Split<'a, fn(char) -> bool>, fn(&&str) -> bool>,

From c4b11d19b85f970b759f14e6dd864512d8c41f66 Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 16:46:16 -0400
Subject: [PATCH 16/18] Revert SplitWhitespace's description

Original headline of SplitWhitespace's description is more descriptive as to what it contains and iterates over.
---
 src/libstd_unicode/u_str.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/libstd_unicode/u_str.rs b/src/libstd_unicode/u_str.rs
index fd309e822a0e5..d3aa27b436d48 100644
--- a/src/libstd_unicode/u_str.rs
+++ b/src/libstd_unicode/u_str.rs
@@ -17,7 +17,8 @@ use core::char;
 use core::iter::{Filter, FusedIterator};
 use core::str::Split;
 
-/// An iterator over sub-slices of the original string slice.
+/// An iterator over the non-whitespace substrings of a string,
+/// separated by any amount of whitespace.
 ///
 /// This struct is created by the [`split_whitespace()`] method on [`str`].
 /// See its documentation for more.

From 3b396217b5b52cf87769263bf0b842c56471b54f Mon Sep 17 00:00:00 2001
From: Donnie Bishop <donnie.a.bishop@gmail.com>
Date: Thu, 30 Mar 2017 18:33:23 -0400
Subject: [PATCH 17/18] Remove parentheses in method references

---
 src/libcollections/str.rs   |  4 ++--
 src/libcore/str/mod.rs      | 16 ++++++++--------
 src/libstd_unicode/u_str.rs |  4 ++--
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index aee6861a09f40..36a1f1eb2b7b2 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -137,10 +137,10 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
 ///
 /// [`u16`]: ../../std/primitive.u16.html
 ///
-/// This struct is created by the [`encode_utf16()`] method on [`str`].
+/// This struct is created by the [`encode_utf16`] method on [`str`].
 /// See its documentation for more.
 ///
-/// [`encode_utf16()`]: ../../std/primitive.str.html#method.encode_utf16
+/// [`encode_utf16`]: ../../std/primitive.str.html#method.encode_utf16
 /// [`str`]: ../../std/primitive.str.html
 #[derive(Clone)]
 #[stable(feature = "encode_utf16", since = "1.8.0")]
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 11d52e3c15bc3..56f42349b2041 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -373,10 +373,10 @@ Section: Iterators
 ///
 /// [`char`]: ../../std/primitive.char.html
 ///
-/// This struct is created by the [`chars()`] method on [`str`].
+/// This struct is created by the [`chars`] method on [`str`].
 /// See its documentation for more.
 ///
-/// [`chars()`]: ../../std/primitive.str.html#method.chars
+/// [`chars`]: ../../std/primitive.str.html#method.chars
 /// [`str`]: ../../std/primitive.str.html
 #[derive(Clone, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -561,10 +561,10 @@ impl<'a> Chars<'a> {
 ///
 /// [`char`]: ../../std/primitive.char.html
 ///
-/// This struct is created by the [`char_indices()`] method on [`str`].
+/// This struct is created by the [`char_indices`] method on [`str`].
 /// See its documentation for more.
 ///
-/// [`char_indices()`]: ../../std/primitive.str.html#method.char_indices
+/// [`char_indices`]: ../../std/primitive.str.html#method.char_indices
 /// [`str`]: ../../std/primitive.str.html
 #[derive(Clone, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -639,10 +639,10 @@ impl<'a> CharIndices<'a> {
 
 /// An iterator over the bytes of a string slice.
 ///
-/// This struct is created by the [`bytes()`] method on [`str`].
+/// This struct is created by the [`bytes`] method on [`str`].
 /// See its documentation for more.
 ///
-/// [`bytes()`]: ../../std/primitive.str.html#method.bytes
+/// [`bytes`]: ../../std/primitive.str.html#method.bytes
 /// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Clone, Debug)]
@@ -1176,10 +1176,10 @@ generate_pattern_iterators! {
 
 /// An iterator over the lines of a string, as string slices.
 ///
-/// This struct is created with the [`lines()`] method on [`str`].
+/// This struct is created with the [`lines`] method on [`str`].
 /// See its documentation for more.
 ///
-/// [`lines()`]: ../../std/primitive.str.html#method.lines
+/// [`lines`]: ../../std/primitive.str.html#method.lines
 /// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Clone, Debug)]
diff --git a/src/libstd_unicode/u_str.rs b/src/libstd_unicode/u_str.rs
index d3aa27b436d48..770b67acd49ef 100644
--- a/src/libstd_unicode/u_str.rs
+++ b/src/libstd_unicode/u_str.rs
@@ -20,10 +20,10 @@ use core::str::Split;
 /// An iterator over the non-whitespace substrings of a string,
 /// separated by any amount of whitespace.
 ///
-/// This struct is created by the [`split_whitespace()`] method on [`str`].
+/// This struct is created by the [`split_whitespace`] method on [`str`].
 /// See its documentation for more.
 ///
-/// [`split_whitespace()`]: ../../std/primitive.str.html#method.split_whitespace
+/// [`split_whitespace`]: ../../std/primitive.str.html#method.split_whitespace
 /// [`str`]: ../../std/primitive.str.html
 #[stable(feature = "split_whitespace", since = "1.1.0")]
 pub struct SplitWhitespace<'a> {

From 0e2d3d41bb42abe1c40585d2ed06aea2840e664f Mon Sep 17 00:00:00 2001
From: Stjepan Glavina <stjepang@gmail.com>
Date: Fri, 31 Mar 2017 16:59:01 +0200
Subject: [PATCH 18/18] Test sort algorithms using a random cmp function

---
 src/libcollectionstest/slice.rs | 16 +++++++++++++++-
 src/libcoretest/slice.rs        | 12 ++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/libcollectionstest/slice.rs b/src/libcollectionstest/slice.rs
index 00d4dbe9c0458..c3e5304fb2b35 100644
--- a/src/libcollectionstest/slice.rs
+++ b/src/libcollectionstest/slice.rs
@@ -383,9 +383,11 @@ fn test_reverse() {
 
 #[test]
 fn test_sort() {
+    let mut rng = thread_rng();
+
     for len in (2..25).chain(500..510) {
         for _ in 0..100 {
-            let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
+            let mut v: Vec<_> = rng.gen_iter::<i32>().take(len).collect();
             let mut v1 = v.clone();
 
             v.sort();
@@ -399,6 +401,18 @@ fn test_sort() {
         }
     }
 
+    // Sort using a completely random comparison function.
+    // This will reorder the elements *somehow*, but won't panic.
+    let mut v = [0; 500];
+    for i in 0..v.len() {
+        v[i] = i as i32;
+    }
+    v.sort_by(|_, _| *rng.choose(&[Less, Equal, Greater]).unwrap());
+    v.sort();
+    for i in 0..v.len() {
+        assert_eq!(v[i], i as i32);
+    }
+
     // Should not panic.
     [0i32; 0].sort();
     [(); 10].sort();
diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs
index 89bd3be08519c..ec38345030fa5 100644
--- a/src/libcoretest/slice.rs
+++ b/src/libcoretest/slice.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core::cmp::Ordering::{Equal, Greater, Less};
 use core::slice::heapsort;
 use core::result::Result::{Ok, Err};
 use rand::{Rng, XorShiftRng};
@@ -268,6 +269,17 @@ fn sort_unstable() {
         }
     }
 
+    // Sort using a completely random comparison function.
+    // This will reorder the elements *somehow*, but won't panic.
+    for i in 0..v.len() {
+        v[i] = i as i32;
+    }
+    v.sort_unstable_by(|_, _| *rng.choose(&[Less, Equal, Greater]).unwrap());
+    v.sort_unstable();
+    for i in 0..v.len() {
+        assert_eq!(v[i], i as i32);
+    }
+
     // Should not panic.
     [0i32; 0].sort_unstable();
     [(); 10].sort_unstable();