Auto merge of #46166 - kennytm:rollup, r=kennytm

Rollup of 11 pull requests - Successful merges: #45987, #46031, #46050, #46052, #46103, #46120, #46134, #46141, #46148, #46155, #46157 - Failed merges:
2017-11-21 17:14:05 +00:00 · 2017-11-21 17:14:05 +00:00 · 63739ab7b2
commit 63739ab7b2
parent f28df20026 7c8b36f6f1
46 changed files with 395 additions and 465 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -421,7 +421,7 @@ Here are those same steps in detail:

 These instructions are specific to updating `rustfmt`, however they may apply
 to the other submodules as well. Please help by improving these instructions
-if you find any discrepencies or special cases that need to be addressed.
+if you find any discrepancies or special cases that need to be addressed.

 To update the `rustfmt` submodule, start by running the appropriate
 [`git submodule` command](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
--- a/RELEASES.md
+++ b/RELEASES.md
@ -5,9 +5,6 @@ Language
 --------
 - [`non_snake_case` lint now allows extern no-mangle functions][44966]
 - [Now accepts underscores in unicode escapes][43716]
- [`#![feature(const_fn)]` is now no longer required for
-  calling const functions.][43017] It's still required for creating
-  constant functions.
 - [`T op= &T` now works for numeric types.][44287] eg. `let mut x = 2; x += &8;`
 - [types that impl `Drop` are now allowed in `const` and `static` types][44456]

@ -45,8 +42,8 @@ Cargo
 Misc
 ----
 - [`libbacktrace` is now available on Apple platforms.][44251]
- [Stabilised the `compile_fail` attribute for code fences.][43949] This now
-  lets you specify that a given code example will fail to compile.
+- [Stabilised the `compile_fail` attribute for code fences in doc-comments.][43949]
+  This now lets you specify that a given code example will fail to compile.

 Compatibility Notes
 -------------------
@ -624,7 +621,7 @@ Misc
 ----

 - [rustdoc can now use pulldown-cmark with the `--enable-commonmark` flag][40338]
- [Added rust-winbg script for better debugging on Windows][39983]
+- [Added rust-windbg script for better debugging on Windows][39983]
 - [Rust now uses the official cross compiler for NetBSD][40612]
 - [rustdoc now accepts `#` at the start of files][40828]
 - [Fixed jemalloc support for musl][41168]
@ -1658,7 +1655,7 @@ Diagnostics
 -----------

 * [Replace macro backtraces with labeled local uses][35702]
-* [Improve error message for missplaced doc comments][33922]
+* [Improve error message for misplaced doc comments][33922]
 * [Buffer unix and lock windows to prevent message interleaving][35975]
 * [Update lifetime errors to specifically note temporaries][36171]
 * [Special case a few colors for Windows][36178]
@ -1966,7 +1963,7 @@ Language
  useful](https://github.com/rust-lang/rust/pull/34908)
 * [`macro_rules!` `stmt` matchers correctly consume the entire contents when
  inside non-braces invocations](https://github.com/rust-lang/rust/pull/34886)
-* [Semicolons are properly required as statement delimeters inside
+* [Semicolons are properly required as statement delimiters inside
  `macro_rules!` invocations](https://github.com/rust-lang/rust/pull/34660)
 * [`cfg_attr` works on `path` attributes](https://github.com/rust-lang/rust/pull/34546)

@ -2191,7 +2188,7 @@ Compatibility Notes
 * [`const`s and `static`s may not have unsized types](https://github.com/rust-lang/rust/pull/34443)
 * [The new follow-set rules that place restrictions on `macro_rules!`
  in order to ensure syntax forward-compatibility have been enabled](https://github.com/rust-lang/rust/pull/33982)
-  This was an [ammendment to RFC 550](https://github.com/rust-lang/rfcs/pull/1384),
+  This was an [amendment to RFC 550](https://github.com/rust-lang/rfcs/pull/1384),
  and has been a warning since 1.10.
 * [`cfg` attribute process has been refactored to fix various bugs](https://github.com/rust-lang/rust/pull/33706).
  This causes breakage in some corner cases.
@ -3348,7 +3345,7 @@ Libraries
 * `FromStr` is [implemented for `SockAddrV4` and `SockAddrV6`][1.5s].
 * There are now `From` conversions [between floating point
  types][1.5f] where the conversions are lossless.
-* Thera are now `From` conversions [between integer types][1.5i] where
+* There are now `From` conversions [between integer types][1.5i] where
  the conversions are lossless.
 * [`fs::Metadata` implements `Clone`][1.5fs].
 * The `parse` method [accepts a leading "+" when parsing
@ -3548,7 +3545,7 @@ Libraries
 * [`IntoIterator` is implemented for references to `Option` and
  `Result`][into2].
 * [`HashMap` and `HashSet` implement `Extend<&T>` where `T:
-  Copy`][ext] as part of [RFC 839]. This will cause type inferance
+  Copy`][ext] as part of [RFC 839]. This will cause type inference
  breakage in rare situations.
 * [`BinaryHeap` implements `Debug`][bh2].
 * [`Borrow` and `BorrowMut` are implemented for fixed-size
@ -3559,7 +3556,7 @@ Libraries
 * `&mut T` where `T: std::fmt::Write` [also implements
  `std::fmt::Write`][mutw].
 * [A stable regression in `VecDeque::push_back` and other
-  capicity-altering methods that caused panics for zero-sized types
+  capacity-altering methods that caused panics for zero-sized types
  was fixed][vd].
 * [Function pointers implement traits for up to 12 parameters][fp2].

@ -3746,7 +3743,7 @@ Libraries
  [better for long data][sh].
 * [`AtomicPtr`] implements [`Send`].
 * The [`read_to_end`] implementations for [`Stdin`] and [`File`]
-  are now [specialized to use uninitalized buffers for increased
+  are now [specialized to use uninitialized buffers for increased
  performance][rte].
 * Lifetime parameters of foreign functions [are now resolved
  properly][f].
@ -3875,7 +3872,7 @@ Highlights
 * This is the first release with [experimental support for linking
  with the MSVC linker and lib C on Windows (instead of using the GNU
  variants via MinGW)][win]. It is yet recommended only for the most
-  intrepid Rusticians.
+  intrepid Rustaceans.
 * Benchmark compilations are showing a 30% improvement in
  bootstrapping over 1.1.

@ -4741,7 +4738,7 @@ Version 0.11.0 (2014-07-02)
  * Libraries
    * The standard library is now a "facade" over a number of underlying
      libraries. This means that development on the standard library should
-      be speeder due to smaller crates, as well as a clearer line between
+      be speedier due to smaller crates, as well as a clearer line between
      all dependencies.
    * A new library, libcore, lives under the standard library's facade
      which is Rust's "0-assumption" library, suitable for embedded and
--- a/src/bootstrap/dist.rs
+++ b/src/bootstrap/dist.rs
@ -1168,7 +1168,12 @@ impl Step for Rustfmt {
            compiler: builder.compiler(stage, build.build),
            target
        }).expect("Rustfmt to build: toolstate is testing");
+        let cargofmt = builder.ensure(tool::Cargofmt {
+            compiler: builder.compiler(stage, build.build),
+            target
+        }).expect("Cargofmt to build: toolstate is testing");
        install(&rustfmt, &image.join("bin"), 0o755);
+        install(&cargofmt, &image.join("bin"), 0o755);
        let doc = image.join("share/doc/rustfmt");
        install(&src.join("README.md"), &doc, 0o644);
        install(&src.join("LICENSE-MIT"), &doc, 0o644);
--- a/src/bootstrap/job.rs
+++ b/src/bootstrap/job.rs
@ -185,7 +185,7 @@ pub unsafe fn setup(build: &mut Build) {
                            0, FALSE, DUPLICATE_SAME_ACCESS);

    // If this failed, well at least we tried! An example of DuplicateHandle
-    // failing in the past has been when the wrong python2 package spawed this
+    // failing in the past has been when the wrong python2 package spawned this
    // build system (e.g. the `python2` package in MSYS instead of
    // `mingw-w64-x86_64-python2`. Not sure why it failed, but the "failure
    // mode" here is that we only clean everything up when the build system
--- a/src/bootstrap/sanity.rs
+++ b/src/bootstrap/sanity.rs
@ -78,7 +78,7 @@ pub fn check(build: &mut Build) {
    }

    let mut cmd_finder = Finder::new();
-    // If we've got a git directory we're gona need git to update
+    // If we've got a git directory we're gonna need git to update
    // submodules and learn about various other aspects.
    if build.rust_info.is_git() {
        cmd_finder.must_have("git");
--- a/src/bootstrap/tool.rs
+++ b/src/bootstrap/tool.rs
@ -403,71 +403,66 @@ impl Step for Cargo {
    }
 }

-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Clippy {
-    pub compiler: Compiler,
-    pub target: Interned<String>,
+macro_rules! tool_extended {
+    (($sel:ident, $builder:ident),
+       $($name:ident,
+       $toolstate:ident,
+       $path:expr,
+       $tool_name:expr,
+       $extra_deps:block;)+) => {
+        $(
+            #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+        pub struct $name {
+            pub compiler: Compiler,
+            pub target: Interned<String>,
+        }
+
+        impl Step for $name {
+            type Output = Option<PathBuf>;
+            const DEFAULT: bool = true;
+            const ONLY_HOSTS: bool = true;
+
+            fn should_run(run: ShouldRun) -> ShouldRun {
+                let builder = run.builder;
+                run.path($path).default_condition(builder.build.config.extended)
+            }
+
+            fn make_run(run: RunConfig) {
+                run.builder.ensure($name {
+                    compiler: run.builder.compiler(run.builder.top_stage, run.builder.build.build),
+                    target: run.target,
+                });
+            }
+
+            fn run($sel, $builder: &Builder) -> Option<PathBuf> {
+                $extra_deps
+                let toolstate = $builder.build.config.toolstate.$toolstate;
+                $builder.ensure(ToolBuild {
+                    compiler: $sel.compiler,
+                    target: $sel.target,
+                    tool: $tool_name,
+                    mode: Mode::Librustc,
+                    path: $path,
+                    expectation: toolstate.passes(ToolState::Compiling),
+                })
+            }
+        }
+        )+
+    }
 }

-impl Step for Clippy {
-    type Output = Option<PathBuf>;
-    const DEFAULT: bool = true;
-    const ONLY_HOSTS: bool = true;
-
-    fn should_run(run: ShouldRun) -> ShouldRun {
-        let builder = run.builder;
-        run.path("src/tools/clippy").default_condition(builder.build.config.extended)
-    }
-
-    fn make_run(run: RunConfig) {
-        run.builder.ensure(Clippy {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.build.build),
-            target: run.target,
-        });
-    }
-
-    fn run(self, builder: &Builder) -> Option<PathBuf> {
+tool_extended!((self, builder),
+    Cargofmt, rustfmt, "src/tools/rustfmt", "cargo-fmt", {};
+    Clippy, clippy, "src/tools/clippy", "clippy-driver", {
        // Clippy depends on procedural macros (serde), which requires a full host
        // compiler to be available, so we need to depend on that.
        builder.ensure(compile::Rustc {
            compiler: self.compiler,
            target: builder.build.build,
        });
-        builder.ensure(ToolBuild {
-            compiler: self.compiler,
-            target: self.target,
-            tool: "clippy-driver",
-            mode: Mode::Librustc,
-            path: "src/tools/clippy",
-            expectation: builder.build.config.toolstate.clippy.passes(ToolState::Compiling),
-        })
-    }
-}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Rls {
-    pub compiler: Compiler,
-    pub target: Interned<String>,
-}
-
-impl Step for Rls {
-    type Output = Option<PathBuf>;
-    const DEFAULT: bool = true;
-    const ONLY_HOSTS: bool = true;
-
-    fn should_run(run: ShouldRun) -> ShouldRun {
-        let builder = run.builder;
-        run.path("src/tools/rls").default_condition(builder.build.config.extended)
-    }
-
-    fn make_run(run: RunConfig) {
-        run.builder.ensure(Rls {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.build.build),
-            target: run.target,
-        });
-    }
-
-    fn run(self, builder: &Builder) -> Option<PathBuf> {
+    };
+    Miri, miri, "src/tools/miri", "miri", {};
+    Rls, rls, "src/tools/rls", "rls", {
        builder.ensure(native::Openssl {
            target: self.target,
        });
@ -477,87 +472,9 @@ impl Step for Rls {
            compiler: self.compiler,
            target: builder.build.build,
        });
-        builder.ensure(ToolBuild {
-            compiler: self.compiler,
-            target: self.target,
-            tool: "rls",
-            mode: Mode::Librustc,
-            path: "src/tools/rls",
-            expectation: builder.build.config.toolstate.rls.passes(ToolState::Compiling),
-        })
-    }
-}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Rustfmt {
-    pub compiler: Compiler,
-    pub target: Interned<String>,
-}
-
-impl Step for Rustfmt {
-    type Output = Option<PathBuf>;
-    const DEFAULT: bool = true;
-    const ONLY_HOSTS: bool = true;
-
-    fn should_run(run: ShouldRun) -> ShouldRun {
-        let builder = run.builder;
-        run.path("src/tools/rustfmt").default_condition(builder.build.config.extended)
-    }
-
-    fn make_run(run: RunConfig) {
-        run.builder.ensure(Rustfmt {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.build.build),
-            target: run.target,
-        });
-    }
-
-    fn run(self, builder: &Builder) -> Option<PathBuf> {
-        builder.ensure(ToolBuild {
-            compiler: self.compiler,
-            target: self.target,
-            tool: "rustfmt",
-            mode: Mode::Librustc,
-            path: "src/tools/rustfmt",
-            expectation: builder.build.config.toolstate.rustfmt.passes(ToolState::Compiling),
-        })
-    }
-}
-
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Miri {
-    pub compiler: Compiler,
-    pub target: Interned<String>,
-}
-
-impl Step for Miri {
-    type Output = Option<PathBuf>;
-    const DEFAULT: bool = true;
-    const ONLY_HOSTS: bool = true;
-
-    fn should_run(run: ShouldRun) -> ShouldRun {
-        let build_miri = run.builder.build.config.test_miri;
-        run.path("src/tools/miri").default_condition(build_miri)
-    }
-
-    fn make_run(run: RunConfig) {
-        run.builder.ensure(Miri {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.build.build),
-            target: run.target,
-        });
-    }
-
-    fn run(self, builder: &Builder) -> Option<PathBuf> {
-        builder.ensure(ToolBuild {
-            compiler: self.compiler,
-            target: self.target,
-            tool: "miri",
-            mode: Mode::Librustc,
-            path: "src/tools/miri",
-            expectation: builder.build.config.toolstate.miri.passes(ToolState::Compiling),
-        })
-    }
-}
+    };
+    Rustfmt, rustfmt, "src/tools/rustfmt", "rustfmt", {};
+);

 impl<'a> Builder<'a> {
    /// Get a `Command` which is ready to run `tool` in `stage` built for
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@ -36,14 +36,14 @@ a Docker image.

    1. Select the "default" virtual machine inside VirtualBox, then click
        "Settings"
-    2. Go to "Shared Folders", click "Add shared foldrer" (the folder icon with
+    2. Go to "Shared Folders", click "Add shared folder" (the folder icon with
        a plus sign), fill in the following information, then click "OK":

        * Folder path: `E:\rust`
        * Folder name: `e/rust`
        * Read-only: ☐ *unchecked*
        * Auto-mount: ☑ *checked*
-        * Make Permanant: ☑ *checked*
+        * Make Permanent: ☑ *checked*

 3. VirtualBox might not support creating symbolic links inside a shared folder
    by default. You can enable it manually by running these from `cmd.exe`:
--- a/src/ci/docker/dist-x86_64-netbsd/build-netbsd-toolchain.sh
+++ b/src/ci/docker/dist-x86_64-netbsd/build-netbsd-toolchain.sh
@ -52,7 +52,7 @@ curl $URL/2017-03-17-netbsd-comp.tgz | \
 cd usr/src

 # The options, in order, do the following
-# * this is an unpriviledged build
+# * this is an unprivileged build
 # * output to a predictable location
 # * disable various uneeded stuff
 MKUNPRIVED=yes TOOLDIR=/x-tools/x86_64-unknown-netbsd \
--- a/src/ci/run.sh
+++ b/src/ci/run.sh
@ -37,7 +37,7 @@ if [ "$DIST_SRC" = "" ]; then
 fi

 # If we're deploying artifacts then we set the release channel, otherwise if
-# we're not deploying then we want to be sure to enable all assertions becauase
+# we're not deploying then we want to be sure to enable all assertions because
 # we'll be running tests
 #
 # FIXME: need a scheme for changing this `nightly` value to `beta` and `stable`
--- a/src/doc/rustdoc/src/command-line-arguments.md
+++ b/src/doc/rustdoc/src/command-line-arguments.md
@ -279,7 +279,7 @@ $ rustdoc README.md --markdown-playground-url https://play.rust-lang.org/
 ```

 When rendering a Markdown file, this flag gives the base URL of the Rust
-Playround, to use for generating `Run` buttons.
+Playground, to use for generating `Run` buttons.


 ## `--markdown-no-toc`: don't generate a table of contents
@ -291,7 +291,7 @@ $ rustdoc README.md --markdown-no-toc
 ```

 When generating documentation from a Markdown file, by default, `rustdoc` will
-generate a table of contents. This flag supresses that, and no TOC will be
+generate a table of contents. This flag suppresses that, and no TOC will be
 generated.


--- a/src/doc/rustdoc/src/documentation-tests.md
+++ b/src/doc/rustdoc/src/documentation-tests.md
@ -50,7 +50,7 @@ running them. Here's the full algorithm rustdoc uses to preprocess examples:
 5. Finally, if the example does not contain `fn main`, the remainder of the
   text is wrapped in `fn main() { your_code }`.

-For more about that caveat in rule 4, see "Documeting Macros" below.
+For more about that caveat in rule 4, see "Documenting Macros" below.

 ## Hiding portions of the example

--- a/src/doc/unstable-book/src/language-features/optin-builtin-traits.md
+++ b/src/doc/unstable-book/src/language-features/optin-builtin-traits.md
@ -10,7 +10,7 @@ The `optin_builtin_traits` feature gate allows you to define auto traits.

 Auto traits, like [`Send`] or [`Sync`] in the standard library, are marker traits
 that are automatically implemented for every type, unless the type, or a type it contains, 
-has explictly opted out via a negative impl. 
+has explicitly opted out via a negative impl. 

 [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
 [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
--- a/src/doc/unstable-book/src/language-features/unboxed-closures.md
+++ b/src/doc/unstable-book/src/language-features/unboxed-closures.md
@ -9,7 +9,7 @@ See Also: [`fn_traits`](library-features/fn-traits.html)
 ----

 The `unboxed_closures` feature allows you to write functions using the `"rust-call"` ABI,
-required for implmenting the [`Fn*`] family of traits. `"rust-call"` functions must have 
+required for implementing the [`Fn*`] family of traits. `"rust-call"` functions must have 
 exactly one (non self) argument, a tuple representing the argument list.

 [`Fn*`]: https://doc.rust-lang.org/std/ops/trait.Fn.html
--- a/src/etc/installer/exe/modpath.iss
+++ b/src/etc/installer/exe/modpath.iss
@ -144,7 +144,7 @@ begin
 	end;
 end;

-// Split a string into an array using passed delimeter
+// Split a string into an array using passed delimiter
 procedure Explode(var Dest: TArrayOfString; Text: String; Separator: String);
 var
 	i: Integer;
--- a/src/liballoc/fmt.rs
+++ b/src/liballoc/fmt.rs
@ -536,7 +536,7 @@ use string;
 /// assert_eq!(s, "Hello, world!");
 /// ```
 ///
-/// Please note that using [`format!`] might be preferrable.
+/// Please note that using [`format!`] might be preferable.
 /// Example:
 ///
 /// ```
--- a/src/liballoc/macros.rs
+++ b/src/liballoc/macros.rs
@ -72,7 +72,7 @@ macro_rules! vec {

 /// Creates a `String` using interpolation of runtime expressions.
 ///
-/// The first argument `format!` recieves is a format string.  This must be a string
+/// The first argument `format!` receives is a format string.  This must be a string
 /// literal.  The power of the formatting string is in the `{}`s contained.
 ///
 /// Additional parameters passed to `format!` replace the `{}`s within the
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@ -346,7 +346,7 @@ impl<T> Rc<T> {
            unsafe {
                let val = ptr::read(&*this); // copy the contained object

-                // Indicate to Weaks that they can't be promoted by decrememting
+                // Indicate to Weaks that they can't be promoted by decrementing
                // the strong count, and then remove the implicit "strong weak"
                // pointer while also handling drop logic by just crafting a
                // fake Weak.
--- a/src/liballoc/string.rs
+++ b/src/liballoc/string.rs
@ -596,7 +596,7 @@ impl String {
    /// Decode a UTF-16 encoded vector `v` into a `String`, returning [`Err`]
    /// if `v` contains any invalid data.
    ///
-    /// [`Err`]: ../../std/result/enum.Result.htlm#variant.Err
+    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err
    ///
    /// # Examples
    ///
--- a/src/liballoc/tests/str.rs
+++ b/src/liballoc/tests/str.rs
@ -1427,12 +1427,12 @@ mod pattern {
        Reject(6, 7),
        Match (7, 7),
    ]);
-    make_test!(str_searcher_mulibyte_haystack, " ", "├──", [
+    make_test!(str_searcher_multibyte_haystack, " ", "├──", [
        Reject(0, 3),
        Reject(3, 6),
        Reject(6, 9),
    ]);
-    make_test!(str_searcher_empty_needle_mulibyte_haystack, "", "├──", [
+    make_test!(str_searcher_empty_needle_multibyte_haystack, "", "├──", [
        Match (0, 0),
        Reject(0, 3),
        Match (3, 3),
@ -1455,7 +1455,7 @@ mod pattern {
        Match (5, 6),
        Reject(6, 7),
    ]);
-    make_test!(char_searcher_mulibyte_haystack, ' ', "├──", [
+    make_test!(char_searcher_multibyte_haystack, ' ', "├──", [
        Reject(0, 3),
        Reject(3, 6),
        Reject(6, 9),
--- a/src/liballoc/vec.rs
+++ b/src/liballoc/vec.rs
@ -1089,7 +1089,7 @@ impl<T> Vec<T> {
        // Memory safety
        //
        // When the Drain is first created, it shortens the length of
-        // the source vector to make sure no uninitalized or moved-from elements
+        // the source vector to make sure no uninitialized or moved-from elements
        // are accessible at all if the Drain's destructor never gets to run.
        //
        // Drain will ptr::read out the values to remove.
--- a/src/libbacktrace/configure
+++ b/src/libbacktrace/configure
@ -14584,7 +14584,7 @@ func_basename ()
 #             to NONDIR_REPLACEMENT.
 #             value returned in "$func_dirname_result"
 #   basename: Compute filename of FILE.
-#             value retuned in "$func_basename_result"
+#             value returned in "$func_basename_result"
 # Implementation must be kept synchronized with func_dirname
 # and func_basename. For efficiency, we do not delegate to
 # those functions but instead duplicate the functionality here.
--- a/src/libbacktrace/ltmain.sh
+++ b/src/libbacktrace/ltmain.sh
@ -177,7 +177,7 @@ basename="s,^.*/,,"
 #             to NONDIR_REPLACEMENT.
 #             value returned in "$func_dirname_result"
 #   basename: Compute filename of FILE.
-#             value retuned in "$func_basename_result"
+#             value returned in "$func_basename_result"
 # Implementation must be kept synchronized with func_dirname
 # and func_basename. For efficiency, we do not delegate to
 # those functions but instead duplicate the functionality here.
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@ -952,7 +952,7 @@ pub trait UpperExp {
 /// assert_eq!(output, "Hello world!");
 /// ```
 ///
-/// Please note that using [`write!`] might be preferrable. Example:
+/// Please note that using [`write!`] might be preferable. Example:
 ///
 /// ```
 /// use std::fmt::Write;
--- a/src/librustc/hir/def_id.rs
+++ b/src/librustc/hir/def_id.rs
@ -17,8 +17,8 @@ use std::u32;

 newtype_index!(CrateNum
    {
-        derive[Debug]
        ENCODABLE = custom
+        DEBUG_FORMAT = "crate{}",

        /// Item definitions in the currently-compiled crate would have the CrateNum
        /// LOCAL_CRATE in their DefId.
@ -172,17 +172,19 @@ pub struct DefId {

 impl fmt::Debug for DefId {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "DefId {{ krate: {:?}, index: {:?}",
-               self.krate, self.index)?;
+        write!(f, "DefId({:?}/{}:{}",
+               self.krate.index(),
+               self.index.address_space().index(),
+               self.index.as_array_index())?;

        ty::tls::with_opt(|opt_tcx| {
            if let Some(tcx) = opt_tcx {
-                write!(f, " => {}", tcx.def_path_debug_str(*self))?;
+                write!(f, " ~ {}", tcx.def_path_debug_str(*self))?;
            }
            Ok(())
        })?;

-        write!(f, " }}")
+        write!(f, ")")
    }
 }

--- a/src/librustc/middle/dead.rs
+++ b/src/librustc/middle/dead.rs
@ -531,13 +531,15 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> {
                      id: ast::NodeId,
                      span: syntax_pos::Span,
                      name: ast::Name,
-                      node_type: &str) {
+                      node_type: &str,
+                      participle: &str) {
        if !name.as_str().starts_with("_") {
            self.tcx
                .lint_node(lint::builtin::DEAD_CODE,
                           id,
                           span,
-                           &format!("{} is never used: `{}`", node_type, name));
+                           &format!("{} is never {}: `{}`",
+                                    node_type, participle, name));
        }
    }
 }
@ -570,7 +572,8 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> {
                item.id,
                span,
                item.name,
-                item.node.descriptive_variant()
+                item.node.descriptive_variant(),
+                "used",
            );
        } else {
            // Only continue if we didn't warn
@ -583,7 +586,8 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> {
                     g: &'tcx hir::Generics,
                     id: ast::NodeId) {
        if self.should_warn_about_variant(&variant.node) {
-            self.warn_dead_code(variant.node.data.id(), variant.span, variant.node.name, "variant");
+            self.warn_dead_code(variant.node.data.id(), variant.span, variant.node.name,
+                                "variant", "constructed");
        } else {
            intravisit::walk_variant(self, variant, g, id);
        }
@ -591,15 +595,15 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> {

    fn visit_foreign_item(&mut self, fi: &'tcx hir::ForeignItem) {
        if self.should_warn_about_foreign_item(fi) {
-            self.warn_dead_code(fi.id, fi.span, fi.name, fi.node.descriptive_variant());
+            self.warn_dead_code(fi.id, fi.span, fi.name,
+                                fi.node.descriptive_variant(), "used");
        }
        intravisit::walk_foreign_item(self, fi);
    }

    fn visit_struct_field(&mut self, field: &'tcx hir::StructField) {
        if self.should_warn_about_field(&field) {
-            self.warn_dead_code(field.id, field.span,
-                                field.name, "field");
+            self.warn_dead_code(field.id, field.span, field.name, "field", "used");
        }
        intravisit::walk_struct_field(self, field);
    }
@ -611,14 +615,15 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> {
                    self.warn_dead_code(impl_item.id,
                                        impl_item.span,
                                        impl_item.name,
-                                        "associated const");
+                                        "associated const",
+                                        "used");
                }
                self.visit_nested_body(body_id)
            }
            hir::ImplItemKind::Method(_, body_id) => {
                if !self.symbol_is_live(impl_item.id, None) {
                    let span = self.tcx.sess.codemap().def_span(impl_item.span);
-                    self.warn_dead_code(impl_item.id, span, impl_item.name, "method");
+                    self.warn_dead_code(impl_item.id, span, impl_item.name, "method", "used");
                }
                self.visit_nested_body(body_id)
            }
--- a/src/librustc_data_structures/array_vec.rs
+++ b/src/librustc_data_structures/array_vec.rs
@ -111,7 +111,7 @@ impl<A: Array> ArrayVec<A> {
        // Memory safety
        //
        // When the Drain is first created, it shortens the length of
-        // the source vector to make sure no uninitalized or moved-from elements
+        // the source vector to make sure no uninitialized or moved-from elements
        // are accessible at all if the Drain's destructor never gets to run.
        //
        // Drain will ptr::read out the values to remove.
--- a/src/librustc_errors/snippet.rs
+++ b/src/librustc_errors/snippet.rs
@ -70,7 +70,7 @@ impl MultilineAnnotation {

    pub fn as_end(&self) -> Annotation {
        Annotation {
-            start_col: self.end_col - 1,
+            start_col: self.end_col.saturating_sub(1),
            end_col: self.end_col,
            is_primary: self.is_primary,
            label: self.label.clone(),
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@ -3680,18 +3680,24 @@ fn sidebar_assoc_items(it: &clean::Item) -> String {
            }
            let mut links = HashSet::new();
            let ret = v.iter()
-                       .filter_map(|i| if let Some(ref i) = i.inner_impl().trait_ {
-                           let i_display = format!("{:#}", i);
-                           let out = Escape(&i_display);
-                           let encoded = small_url_encode(&format!("{:#}", i));
-                           let generated = format!("<a href=\"#impl-{}\">{}</a>", encoded, out);
-                           if !links.contains(&generated) && links.insert(generated.clone()) {
-                               Some(generated)
+                       .filter_map(|i| {
+                           let is_negative_impl = is_negative_impl(i.inner_impl());
+                           if let Some(ref i) = i.inner_impl().trait_ {
+                               let i_display = format!("{:#}", i);
+                               let out = Escape(&i_display);
+                               let encoded = small_url_encode(&format!("{:#}", i));
+                               let generated = format!("<a href=\"#impl-{}\">{}{}</a>",
+                                                       encoded,
+                                                       if is_negative_impl { "!" } else { "" },
+                                                       out);
+                               if !links.contains(&generated) && links.insert(generated.clone()) {
+                                   Some(generated)
+                               } else {
+                                   None
+                               }
                           } else {
                               None
                           }
-                       } else {
-                           None
                       })
                       .collect::<String>();
            if !ret.is_empty() {
@ -3738,6 +3744,10 @@ fn extract_for_impl_name(item: &clean::Item) -> Option<(String, String)> {
    }
 }

+fn is_negative_impl(i: &clean::Impl) -> bool {
+    i.polarity == Some(clean::ImplPolarity::Negative)
+}
+
 fn sidebar_trait(fmt: &mut fmt::Formatter, it: &clean::Item,
                 t: &clean::Trait) -> fmt::Result {
    let mut sidebar = String::new();
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@ -366,16 +366,13 @@ fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>
 fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
    let start_len = buf.len();
    let mut g = Guard { len: buf.len(), buf: buf };
-    let mut new_write_size = 16;
    let ret;
    loop {
        if g.len == g.buf.len() {
-            if new_write_size < DEFAULT_BUF_SIZE {
-                new_write_size *= 2;
-            }
            unsafe {
-                g.buf.reserve(new_write_size);
-                g.buf.set_len(g.len + new_write_size);
+                g.buf.reserve(32);
+                let capacity = g.buf.capacity();
+                g.buf.set_len(capacity);
                r.initializer().initialize(&mut g.buf[g.len..]);
            }
        }
--- a/src/libstd/net/addr.rs
+++ b/src/libstd/net/addr.rs
@ -759,7 +759,7 @@ impl hash::Hash for SocketAddrV6 {
 /// ```
 ///
 /// [`TcpStream::connect`] is an example of an function that utilizes
-/// `ToSocketsAddr` as a trait bound on its parameter in order to accept
+/// `ToSocketAddrs` as a trait bound on its parameter in order to accept
 /// different types:
 ///
 /// ```no_run
--- a/src/libstd/path.rs
+++ b/src/libstd/path.rs
@ -3752,7 +3752,7 @@ mod tests {
    }

    #[test]
-    fn test_eq_recievers() {
+    fn test_eq_receivers() {
        use borrow::Cow;

        let borrowed: &Path = Path::new("foo/bar");
--- a/src/libsyntax/json.rs
+++ b/src/libsyntax/json.rs
@ -24,11 +24,12 @@ use syntax_pos::{self, MacroBacktrace, Span, SpanLabel, MultiSpan};
 use errors::registry::Registry;
 use errors::{DiagnosticBuilder, SubDiagnostic, CodeSuggestion, CodeMapper};
 use errors::DiagnosticId;
-use errors::emitter::Emitter;
+use errors::emitter::{Emitter, EmitterWriter};

 use std::rc::Rc;
 use std::io::{self, Write};
 use std::vec;
+use std::sync::{Arc, Mutex};

 use rustc_serialize::json::{as_json, as_pretty_json};

@ -95,7 +96,7 @@ struct Diagnostic {
    spans: Vec<DiagnosticSpan>,
    /// Associated diagnostic messages.
    children: Vec<Diagnostic>,
-    /// The message as rustc would render it. Currently this is always `None`
+    /// The message as rustc would render it.
    rendered: Option<String>,
 }

@ -170,6 +171,27 @@ impl Diagnostic {
                rendered: None,
            }
        });
+
+        // generate regular command line output and store it in the json
+
+        // A threadsafe buffer for writing.
+        #[derive(Default, Clone)]
+        struct BufWriter(Arc<Mutex<Vec<u8>>>);
+
+        impl Write for BufWriter {
+            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+                self.0.lock().unwrap().write(buf)
+            }
+            fn flush(&mut self) -> io::Result<()> {
+                self.0.lock().unwrap().flush()
+            }
+        }
+        let buf = BufWriter::default();
+        let output = buf.clone();
+        EmitterWriter::new(Box::new(buf), Some(je.cm.clone()), false).emit(db);
+        let output = Arc::try_unwrap(output.0).unwrap().into_inner().unwrap();
+        let output = String::from_utf8(output).unwrap();
+
        Diagnostic {
            message: db.message(),
            code: DiagnosticCode::map_opt_string(db.code.clone(), je),
@ -178,7 +200,7 @@ impl Diagnostic {
            children: db.children.iter().map(|c| {
                Diagnostic::from_sub_diagnostic(c, je)
            }).chain(sugg).collect(),
-            rendered: None,
+            rendered: Some(output),
        }
    }

--- a/src/test/compile-fail/lint-dead-code-1.rs
+++ b/src/test/compile-fail/lint-dead-code-1.rs
@ -74,7 +74,7 @@ pub enum pub_enum3 {
 enum priv_enum { foo2, bar2 } //~ ERROR: enum is never used
 enum used_enum {
    foo3,
-    bar3 //~ ERROR variant is never used
+    bar3 //~ ERROR variant is never constructed
 }

 fn f<T>() {}
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@ -22,8 +22,8 @@ fn field_read(f: Foo) -> usize {
 }

 enum XYZ {
-    X, //~ ERROR variant is never used
-    Y { //~ ERROR variant is never used
+    X, //~ ERROR variant is never constructed
+    Y { //~ ERROR variant is never constructed
        a: String,
        b: i32,
        c: i32,
@ -43,13 +43,13 @@ enum ABC { //~ ERROR enum is never used

 // ensure struct variants get warning for their fields
 enum IJK {
-    I, //~ ERROR variant is never used
+    I, //~ ERROR variant is never constructed
    J {
        a: String,
        b: i32, //~ ERROR field is never used
        c: i32, //~ ERROR field is never used
    },
-    K //~ ERROR variant is never used
+    K //~ ERROR variant is never constructed

 }

--- a/src/test/compile-fail/lint-dead-code-5.rs
+++ b/src/test/compile-fail/lint-dead-code-5.rs
@ -13,15 +13,15 @@

 enum Enum1 {
    Variant1(isize),
-    Variant2 //~ ERROR: variant is never used
+    Variant2 //~ ERROR: variant is never constructed
 }

 enum Enum2 {
    Variant3(bool),
    #[allow(dead_code)]
    Variant4(isize),
-    Variant5 { _x: isize }, //~ ERROR: variant is never used: `Variant5`
-    Variant6(isize), //~ ERROR: variant is never used: `Variant6`
+    Variant5 { _x: isize }, //~ ERROR: variant is never constructed: `Variant5`
+    Variant6(isize), //~ ERROR: variant is never constructed: `Variant6`
    _Variant7,
 }

--- a/src/test/compile-fail/lint-dead-code-variant.rs
+++ b/src/test/compile-fail/lint-dead-code-variant.rs
@ -12,7 +12,7 @@

 #[derive(Clone)]
 enum Enum {
-    Variant1, //~ ERROR: variant is never used
+    Variant1, //~ ERROR: variant is never constructed
    Variant2,
 }

--- a/src/test/incremental/hashes/let_expressions.rs
+++ b/src/test/incremental/hashes/let_expressions.rs
@ -32,26 +32,9 @@ pub fn change_name() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
-#[rustc_metadata_clean(cfg="cfail2")]
-#[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_clean(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 pub fn change_name() {
    let _y = 2u64;
 }
@ -65,26 +48,11 @@ pub fn add_type() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_clean(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_clean(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn add_type() {
    let _x: u32 = 2u32;
 }
@ -98,26 +66,11 @@ pub fn change_type() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_type() {
    let _x: u8 = 2;
 }
@ -131,26 +84,11 @@ pub fn change_mutability_of_reference_type() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_clean(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_mutability_of_reference_type() {
    let _x: &mut u64;
 }
@ -164,26 +102,11 @@ pub fn change_mutability_of_slot() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_mutability_of_slot() {
    let _x: u64 = 0;
 }
@ -197,26 +120,11 @@ pub fn change_simple_binding_to_pattern() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_simple_binding_to_pattern() {
    let (_a, _b) = (0u8, 'x');
 }
@ -230,26 +138,11 @@ pub fn change_name_in_pattern() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_clean(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_name_in_pattern() {
    let (_a, _c) = (1u8, 'y');
 }
@ -263,26 +156,11 @@ pub fn add_ref_in_pattern() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn add_ref_in_pattern() {
    let (ref _a, _b) = (1u8, 'y');
 }
@ -296,18 +174,11 @@ pub fn add_amp_in_pattern() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
 pub fn add_amp_in_pattern() {
    let (&_a, _b) = (&1u8, 'y');
 }
@ -321,26 +192,11 @@ pub fn change_mutability_of_binding_in_pattern() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_mutability_of_binding_in_pattern() {
    let (mut _a, _b) = (99u8, 'q');
 }
@ -354,26 +210,11 @@ pub fn add_initializer() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,TypeckTables,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_dirty(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn add_initializer() {
    let _x: i16 = 3i16;
 }
@ -387,26 +228,11 @@ pub fn change_initializer() {
 }

 #[cfg(not(cfail1))]
-#[rustc_clean(label="Hir", cfg="cfail2")]
-#[rustc_clean(label="Hir", cfg="cfail3")]
-#[rustc_dirty(label="HirBody", cfg="cfail2")]
-#[rustc_clean(label="HirBody", cfg="cfail3")]
+#[rustc_clean(cfg="cfail2",
+    except="HirBody,MirValidated,MirOptimized")]
+#[rustc_clean(cfg="cfail3")]
 #[rustc_metadata_clean(cfg="cfail2")]
 #[rustc_metadata_clean(cfg="cfail3")]
-#[rustc_dirty(label="MirValidated", cfg="cfail2")]
-#[rustc_clean(label="MirValidated", cfg="cfail3")]
-#[rustc_dirty(label="MirOptimized", cfg="cfail2")]
-#[rustc_clean(label="MirOptimized", cfg="cfail3")]
-#[rustc_clean(label="TypeckTables", cfg="cfail2")]
-#[rustc_clean(label="TypeckTables", cfg="cfail3")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail2")]
-#[rustc_clean(label="TypeOfItem", cfg="cfail3")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail2")]
-#[rustc_clean(label="GenericsOfItem", cfg="cfail3")]
-#[rustc_clean(label="FnSignature", cfg="cfail2")]
-#[rustc_clean(label="FnSignature", cfg="cfail3")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail2")]
-#[rustc_clean(label="PredicatesOfItem", cfg="cfail3")]
 pub fn change_initializer() {
    let _x = 5u16;
 }
--- a/src/test/mir-opt/issue-41697.rs
+++ b/src/test/mir-opt/issue-41697.rs
@ -12,7 +12,7 @@
 // artificial cycles: during type-checking, we had to get the MIR for
 // the constant expressions in `[u8; 2]`, which in turn would trigger
 // an attempt to get the item-path, which in turn would request the
-// types of the impl, which would trigger a cycle. We supressed this
+// types of the impl, which would trigger a cycle. We suppressed this
 // cycle now by forcing mir-dump to avoid asking for types of an impl.

 #![feature(rustc_attrs)]
--- a/src/test/mir-opt/validate_1.rs
+++ b/src/test/mir-opt/validate_1.rs
@ -30,7 +30,7 @@ fn main() {
 // END RUST SOURCE
 // START rustc.{{impl}}-foo.EraseRegions.after.mir
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(0:5) => validate_1[317d]::{{impl}}[0]::foo[0] }, BrAnon(0)) Test, _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(0:5) => validate_1[317d]::{{impl}}[0]::foo[0] }, BrAnon(1)) mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/0:5 ~ validate_1[317d]::{{impl}}[0]::foo[0]), BrAnon(0)) Test, _2: &ReFree(DefId(0/0:5 ~ validate_1[317d]::{{impl}}[0]::foo[0]), BrAnon(1)) mut i32]);
 //         ...
 //         return;
 //     }
@ -62,7 +62,7 @@ fn main() {
 // fn main::{{closure}}(_1: &ReErased [closure@NodeId(50)], _2: &ReErased mut i32) -> i32 {
 //     ...
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(50)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:11) => validate_1[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/1:11 ~ validate_1[317d]::main[0]::{{closure}}[0]), BrEnv) [closure@NodeId(50)], _2: &ReFree(DefId(0/1:11 ~ validate_1[317d]::main[0]::{{closure}}[0]), BrAnon(0)) mut i32]);
 //         StorageLive(_3);
 //         Validate(Suspend(ReScope(Remainder(BlockRemainder { block: ItemLocalId(22), first_statement_index: 0 }))), [(*_2): i32]);
 //         _3 = &ReErased (*_2);
--- a/src/test/mir-opt/validate_4.rs
+++ b/src/test/mir-opt/validate_4.rs
@ -51,8 +51,8 @@ fn main() {
 // fn write_42::{{closure}}(_1: &ReErased [closure@NodeId(22)], _2: *mut i32) -> () {
 //     ...
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_4[317d]::write_42[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(22)], _2: *mut i32]);
-//         Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_4[317d]::write_42[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(22)], _2: *mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/1:9 ~ validate_4[317d]::write_42[0]::{{closure}}[0]), BrEnv) [closure@NodeId(22)], _2: *mut i32]);
+//         Validate(Release, [_1: &ReFree(DefId(0/1:9 ~ validate_4[317d]::write_42[0]::{{closure}}[0]), BrEnv) [closure@NodeId(22)], _2: *mut i32]);
 //         (*_2) = const 23i32;
 //         return;
 //     }
@ -62,8 +62,8 @@ fn main() {
 // fn test(_1: &ReErased mut i32) -> () {
 //     ...
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(0:4) => validate_4[317d]::test[0] }, BrAnon(0)) mut i32]);
-//         Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(0:4) => validate_4[317d]::test[0] }, BrAnon(0)) mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/0:4 ~ validate_4[317d]::test[0]), BrAnon(0)) mut i32]);
+//         Validate(Release, [_1: &ReFree(DefId(0/0:4 ~ validate_4[317d]::test[0]), BrAnon(0)) mut i32]);
 //         ...
 //         _2 = const write_42(_3) -> bb1;
 //     }
@ -78,8 +78,8 @@ fn main() {
 // fn main::{{closure}}(_1: &ReErased [closure@NodeId(60)], _2: &ReErased mut i32) -> bool {
 //     ...
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
-//         Validate(Release, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:10) => validate_4[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/1:10 ~ validate_4[317d]::main[0]::{{closure}}[0]), BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId(0/1:10 ~ validate_4[317d]::main[0]::{{closure}}[0]), BrAnon(0)) mut i32]);
+//         Validate(Release, [_1: &ReFree(DefId(0/1:10 ~ validate_4[317d]::main[0]::{{closure}}[0]), BrEnv) [closure@NodeId(60)], _2: &ReFree(DefId(0/1:10 ~ validate_4[317d]::main[0]::{{closure}}[0]), BrAnon(0)) mut i32]);
 //         StorageLive(_3);
 //         ...
 //         _0 = const write_42(_3) -> bb1;
--- a/src/test/mir-opt/validate_5.rs
+++ b/src/test/mir-opt/validate_5.rs
@ -37,7 +37,7 @@ fn main() {
 // fn test(_1: &ReErased mut i32) -> () {
 //     ...
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(0:4) => validate_5[317d]::test[0] }, BrAnon(0)) mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/0:4 ~ validate_5[317d]::test[0]), BrAnon(0)) mut i32]);
 //         ...
 //         Validate(Release, [_2: bool, _3: *mut i32]);
 //         _2 = const write_42(_3) -> bb1;
@ -49,7 +49,7 @@ fn main() {
 // fn main::{{closure}}(_1: &ReErased [closure@NodeId(46)], _2: &ReErased mut i32) -> bool {
 //     ...
 //     bb0: {
-//         Validate(Acquire, [_1: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrEnv) [closure@NodeId(46)], _2: &ReFree(DefId { krate: CrateNum(0), index: DefIndex(1:9) => validate_5[317d]::main[0]::{{closure}}[0] }, BrAnon(0)) mut i32]);
+//         Validate(Acquire, [_1: &ReFree(DefId(0/1:9 ~ validate_5[317d]::main[0]::{{closure}}[0]), BrEnv) [closure@NodeId(46)], _2: &ReFree(DefId(0/1:9 ~ validate_5[317d]::main[0]::{{closure}}[0]), BrAnon(0)) mut i32]);
 //         StorageLive(_3);
 //         StorageLive(_4);
 //         Validate(Suspend(ReScope(Node(ItemLocalId(9)))), [(*_2): i32]);
--- a/src/test/rustdoc/negative-impl-sidebar.rs
+++ b/src/test/rustdoc/negative-impl-sidebar.rs
@ -0,0 +1,19 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(optin_builtin_traits)]
+#![crate_name = "foo"]
+
+pub struct Foo;
+
+// @has foo/struct.Foo.html
+// @has - '//*[@class="sidebar-title"][@href="#implementations"]' 'Trait Implementations'
+// @has - '//*[@class="sidebar-links"]/a' '!Sync'
+impl !Sync for Foo {}
--- a/src/test/ui/lint/unused_parens_json_suggestion.stderr
+++ b/src/test/ui/lint/unused_parens_json_suggestion.stderr
@ -87,5 +87,17 @@
      "rendered": null
    }
  ],
-  "rendered": null
+  "rendered": "warning: unnecessary parentheses around assigned value
+  --> $DIR/unused_parens_json_suggestion.rs:24:14
+   |
+24 |     let _a = (1 / (2 + 3));
+   |              ^^^^^^^^^^^^^ help: remove these parentheses
+   |
+note: lint level defined here
+  --> $DIR/unused_parens_json_suggestion.rs:19:9
+   |
+19 | #![warn(unused_parens)]
+   |         ^^^^^^^^^^^^^
+
+"
 }
--- a/src/test/ui/lint/use_suggestion_json.stderr
+++ b/src/test/ui/lint/use_suggestion_json.stderr
@ -2,7 +2,72 @@
  "message": "cannot find type `Iter` in this scope",
  "code": {
    "code": "E0412",
-    "explanation": "/nThe type name used is not in scope./n/nErroneous code examples:/n/n```compile_fail,E0412/nimpl Something {} // error: type name `Something` is not in scope/n/n// or:/n/ntrait Foo {/n    fn bar(N); // error: type name `N` is not in scope/n}/n/n// or:/n/nfn foo(x: T) {} // type name `T` is not in scope/n```/n/nTo fix this error, please verify you didn't misspell the type name, you did/ndeclare it or imported it into the scope. Examples:/n/n```/nstruct Something;/n/nimpl Something {} // ok!/n/n// or:/n/ntrait Foo {/n    type N;/n/n    fn bar(_: Self::N); // ok!/n}/n/n// or:/n/nfn foo<T>(x: T) {} // ok!/n```/n/nAnother case that causes this error is when a type is imported into a parent/nmodule. To fix this, you can follow the suggestion and use File directly or/n`use super::File;` which will import the types from the parent namespace. An/nexample that causes this error is below:/n/n```compile_fail,E0412/nuse std::fs::File;/n/nmod foo {/n    fn some_function(f: File) {}/n}/n```/n/n```/nuse std::fs::File;/n/nmod foo {/n    // either/n    use super::File;/n    // or/n    // use std::fs::File;/n    fn foo(f: File) {}/n}/n# fn main() {} // don't insert it for us; that'll break imports/n```/n"
+    "explanation": "
+The type name used is not in scope.
+
+Erroneous code examples:
+
+```compile_fail,E0412
+impl Something {} // error: type name `Something` is not in scope
+
+// or:
+
+trait Foo {
+    fn bar(N); // error: type name `N` is not in scope
+}
+
+// or:
+
+fn foo(x: T) {} // type name `T` is not in scope
+```
+
+To fix this error, please verify you didn't misspell the type name, you did
+declare it or imported it into the scope. Examples:
+
+```
+struct Something;
+
+impl Something {} // ok!
+
+// or:
+
+trait Foo {
+    type N;
+
+    fn bar(_: Self::N); // ok!
+}
+
+// or:
+
+fn foo<T>(x: T) {} // ok!
+```
+
+Another case that causes this error is when a type is imported into a parent
+module. To fix this, you can follow the suggestion and use File directly or
+`use super::File;` which will import the types from the parent namespace. An
+example that causes this error is below:
+
+```compile_fail,E0412
+use std::fs::File;
+
+mod foo {
+    fn some_function(f: File) {}
+}
+```
+
+```
+use std::fs::File;
+
+mod foo {
+    // either
+    use super::File;
+    // or
+    // use std::fs::File;
+    fn foo(f: File) {}
+}
+# fn main() {} // don't insert it for us; that'll break imports
+```
+"
  },
  "level": "error",
  "spans": [
@ -50,7 +115,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::binary_heap::Iter;/n/n",
+          "suggested_replacement": "use std::collections::binary_heap::Iter;
+
+",
          "expansion": null
        },
        {
@ -70,7 +137,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::btree_map::Iter;/n/n",
+          "suggested_replacement": "use std::collections::btree_map::Iter;
+
+",
          "expansion": null
        },
        {
@ -90,7 +159,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::btree_set::Iter;/n/n",
+          "suggested_replacement": "use std::collections::btree_set::Iter;
+
+",
          "expansion": null
        },
        {
@ -110,7 +181,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::hash_map::Iter;/n/n",
+          "suggested_replacement": "use std::collections::hash_map::Iter;
+
+",
          "expansion": null
        },
        {
@ -130,7 +203,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::hash_set::Iter;/n/n",
+          "suggested_replacement": "use std::collections::hash_set::Iter;
+
+",
          "expansion": null
        },
        {
@ -150,7 +225,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::linked_list::Iter;/n/n",
+          "suggested_replacement": "use std::collections::linked_list::Iter;
+
+",
          "expansion": null
        },
        {
@ -170,7 +247,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::collections::vec_deque::Iter;/n/n",
+          "suggested_replacement": "use std::collections::vec_deque::Iter;
+
+",
          "expansion": null
        },
        {
@ -190,7 +269,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::option::Iter;/n/n",
+          "suggested_replacement": "use std::option::Iter;
+
+",
          "expansion": null
        },
        {
@ -210,7 +291,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::path::Iter;/n/n",
+          "suggested_replacement": "use std::path::Iter;
+
+",
          "expansion": null
        },
        {
@ -230,7 +313,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::result::Iter;/n/n",
+          "suggested_replacement": "use std::result::Iter;
+
+",
          "expansion": null
        },
        {
@ -250,7 +335,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::slice::Iter;/n/n",
+          "suggested_replacement": "use std::slice::Iter;
+
+",
          "expansion": null
        },
        {
@ -270,7 +357,9 @@
            }
          ],
          "label": null,
-          "suggested_replacement": "use std::sync::mpsc::Iter;/n/n",
+          "suggested_replacement": "use std::sync::mpsc::Iter;
+
+",
          "expansion": null
        }
      ],
@ -278,7 +367,24 @@
      "rendered": null
    }
  ],
-  "rendered": null
+  "rendered": "error[E0412]: cannot find type `Iter` in this scope
+  --> $DIR/use_suggestion_json.rs:20:12
+   |
+20 |     let x: Iter;
+   |            ^^^^ not found in this scope
+help: possible candidates are found in other modules, you can import them into scope
+   |
+19 | use std::collections::binary_heap::Iter;
+   |
+19 | use std::collections::btree_map::Iter;
+   |
+19 | use std::collections::btree_set::Iter;
+   |
+19 | use std::collections::hash_map::Iter;
+   |
+and 8 other candidates
+
+"
 }
 {
  "message": "aborting due to previous error",
@ -286,5 +392,7 @@
  "level": "error",
  "spans": [],
  "children": [],
-  "rendered": null
+  "rendered": "error: aborting due to previous error
+
+"
 }
--- a/src/tools/cargotest/main.rs
+++ b/src/tools/cargotest/main.rs
@ -60,8 +60,8 @@ const TEST_REPOS: &'static [Test] = &[
    },
    Test {
        name: "servo",
-        repo: "https://github.com/eddyb/servo",
-        sha: "6031de9a397e2feba4ff98725991825f62b68518",
+        repo: "https://github.com/servo/servo",
+        sha: "17e97b9320fdb7cdb33bbc5f4d0fde0653bbf2e4",
        lock: None,
        // Only test Stylo a.k.a. Quantum CSS, the parts of Servo going into Firefox.
        // This takes much less time to build than all of Servo and supports stable Rust.
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@ -2424,15 +2424,25 @@ actual:\n\
    fn normalize_output(&self, output: &str, custom_rules: &[(String, String)]) -> String {
        let parent_dir = self.testpaths.file.parent().unwrap();
        let cflags = self.props.compile_flags.join(" ");
-        let parent_dir_str = if cflags.contains("--error-format json")
-                             || cflags.contains("--error-format pretty-json") {
+        let json = cflags.contains("--error-format json") ||
+                   cflags.contains("--error-format pretty-json");
+        let parent_dir_str = if json {
            parent_dir.display().to_string().replace("\\", "\\\\")
        } else {
            parent_dir.display().to_string()
        };

-        let mut normalized = output.replace(&parent_dir_str, "$DIR")
-              .replace("\\\\", "\\") // denormalize for paths on windows
+        let mut normalized = output.replace(&parent_dir_str, "$DIR");
+
+        if json {
+            // escaped newlines in json strings should be readable
+            // in the stderr files. There's no point int being correct,
+            // since only humans process the stderr files.
+            // Thus we just turn escaped newlines back into newlines.
+            normalized = normalized.replace("\\n", "\n");
+        }
+
+        normalized = normalized.replace("\\\\", "\\") // denormalize for paths on windows
              .replace("\\", "/") // normalize for paths on windows
              .replace("\r\n", "\n") // normalize for linebreaks on windows
              .replace("\t", "\\t"); // makes tabs visible