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

Rollup of 13 pull requests

- Successful merges: #48201, #48705, #48725, #48824, #48877, #48880, #48887, #48928, #48934, #48480, #48631, #48898, #48954
- Failed merges:

33 files changed, 221 insertions, 266 deletions

diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index e9b39717c70..d70b2b52aca 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -11,9 +11,9 @@ A version of this document [can be found online](https://www.rust-lang.org/condu
 * Please be kind and courteous. There's no need to be mean or rude.
 * Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
 * Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
-* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behaviour. We interpret the term "harassment" as including the definition in the <a href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>; if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don't tolerate behavior that excludes people in socially marginalized groups.
+* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term "harassment" as including the definition in the <a href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>; if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don't tolerate behavior that excludes people in socially marginalized groups.
 * Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or any of the [Rust moderation team][mod_team] immediately. Whether you're a regular contributor or a newcomer, we care about making this community a safe place for you and we've got your back.
-* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behaviour is not welcome.
+* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
 
 ## Moderation
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 552961b9b66..2b389888e51 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -26,10 +26,10 @@ As a reminder, all contributors are expected to follow our [Code of Conduct][coc
 ## Feature Requests
 [feature-requests]: #feature-requests
 
-To request a change to the way that the Rust language works, please open an
-issue in the [RFCs repository](https://github.com/rust-lang/rfcs/issues/new)
-rather than this one. New features and other significant language changes
-must go through the RFC process.
+To request a change to the way the Rust language works, please head over
+to the [RFCs repository](https://github.com/rust-lang/rfcs) and view the 
+[README](https://github.com/rust-lang/rfcs/blob/master/README.md)
+for instructions.
 
 ## Bug Reports
 [bug-reports]: #bug-reports
diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs
index 2f57c53a6d8..1bb2bed463b 100644
--- a/src/liballoc/vec.rs
+++ b/src/liballoc/vec.rs
@@ -1212,8 +1212,9 @@ impl<T: Clone> Vec<T> {
     /// difference, with each additional slot filled with `value`.
     /// If `new_len` is less than `len`, the `Vec` is simply truncated.
     ///
-    /// This method requires `Clone` to clone the passed value. If you'd
-    /// rather create a value with `Default` instead, see [`resize_default`].
+    /// This method requires [`Clone`] to be able clone the passed value. If
+    /// you'd rather create a value with [`Default`] instead, see
+    /// [`resize_default`].
     ///
     /// # Examples
     ///
@@ -1227,6 +1228,8 @@ impl<T: Clone> Vec<T> {
     /// assert_eq!(vec, [1, 2]);
     /// ```
     ///
+    /// [`Clone`]: ../../std/clone/trait.Clone.html
+    /// [`Default`]: ../../std/default/trait.Default.html
     /// [`resize_default`]: #method.resize_default
     #[stable(feature = "vec_resize", since = "1.5.0")]
     pub fn resize(&mut self, new_len: usize, value: T) {
@@ -1244,7 +1247,7 @@ impl<T: Clone> Vec<T> {
     /// Iterates over the slice `other`, clones each element, and then appends
     /// it to this `Vec`. The `other` vector is traversed in-order.
     ///
-    /// Note that this function is same as `extend` except that it is
+    /// Note that this function is same as [`extend`] except that it is
     /// specialized to work with slices instead. If and when Rust gets
     /// specialization this function will likely be deprecated (but still
     /// available).
@@ -1256,6 +1259,8 @@ impl<T: Clone> Vec<T> {
     /// vec.extend_from_slice(&[2, 3, 4]);
     /// assert_eq!(vec, [1, 2, 3, 4]);
     /// ```
+    ///
+    /// [`extend`]: #method.extend
     #[stable(feature = "vec_extend_from_slice", since = "1.6.0")]
     pub fn extend_from_slice(&mut self, other: &[T]) {
         self.spec_extend(other.iter())
@@ -1266,12 +1271,11 @@ impl<T: Default> Vec<T> {
     /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
     ///
     /// If `new_len` is greater than `len`, the `Vec` is extended by the
-    /// difference, with each additional slot filled with `Default::default()`.
+    /// difference, with each additional slot filled with [`Default::default()`].
     /// If `new_len` is less than `len`, the `Vec` is simply truncated.
     ///
-    /// This method uses `Default` to create new values on every push. If
-    /// you'd rather `Clone` a given value, use [`resize`].
-    ///
+    /// This method uses [`Default`] to create new values on every push. If
+    /// you'd rather [`Clone`] a given value, use [`resize`].
     ///
     /// # Examples
     ///
@@ -1288,6 +1292,9 @@ impl<T: Default> Vec<T> {
     /// ```
     ///
     /// [`resize`]: #method.resize
+    /// [`Default::default()`]: ../../std/default/trait.Default.html#tymethod.default
+    /// [`Default`]: ../../std/default/trait.Default.html
+    /// [`Clone`]: ../../std/clone/trait.Clone.html
     #[unstable(feature = "vec_resize_default", issue = "41758")]
     pub fn resize_default(&mut self, new_len: usize) {
         let len = self.len();
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index 1372151b753..36618e86968 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -1203,21 +1203,42 @@ impl<'a, T: ?Sized + fmt::Display> fmt::Display for RefMut<'a, T> {
 /// The `UnsafeCell<T>` type is the only legal way to obtain aliasable data that is considered
 /// mutable. In general, transmuting an `&T` type into an `&mut T` is considered undefined behavior.
 ///
-/// The compiler makes optimizations based on the knowledge that `&T` is not mutably aliased or
-/// mutated, and that `&mut T` is unique. When building abstractions like `Cell`, `RefCell`,
-/// `Mutex`, etc, you need to turn these optimizations off. `UnsafeCell` is the only legal way
-/// to do this. When `UnsafeCell<T>` is immutably aliased, it is still safe to obtain a mutable
-/// reference to its interior and/or to mutate it. However, it is up to the abstraction designer
-/// to ensure that no two mutable references obtained this way are active at the same time, and
-/// that there are no active mutable references or mutations when an immutable reference is obtained
-/// from the cell. This is often done via runtime checks.
+/// If you have a reference `&SomeStruct`, then normally in Rust all fields of `SomeStruct` are
+/// immutable. The compiler makes optimizations based on the knowledge that `&T` is not mutably
+/// aliased or mutated, and that `&mut T` is unique. `UnsafeCel<T>` is the only core language
+/// feature to work around this restriction. All other types that allow internal mutability, such as
+/// `Cell<T>` and `RefCell<T>` use `UnsafeCell` to wrap their internal data.
 ///
-/// Note that while mutating or mutably aliasing the contents of an `& UnsafeCell<T>` is
-/// okay (provided you enforce the invariants some other way); it is still undefined behavior
-/// to have multiple `&mut UnsafeCell<T>` aliases.
+/// The `UnsafeCell` API itself is technically very simple: it gives you a raw pointer `*mut T` to
+/// its contents. It is up to _you_ as the abstraction designer to use that raw pointer correctly.
+///
+/// The precise Rust aliasing rules are somewhat in flux, but the main points are not contentious:
+///
+/// - If you create a safe reference with lifetime `'a` (either a `&T` or `&mut T` reference) that
+/// is accessible by safe code (for example, because you returned it), then you must not access
+/// the data in any way that contradicts that reference for the remainder of `'a`. For example, that
+/// means that if you take the `*mut T` from an `UnsafeCell<T>` and case it to an `&T`, then until
+/// that reference's lifetime expires, the data in `T` must remain immutable (modulo any
+/// `UnsafeCell` data found within `T`, of course). Similarly, if you create an `&mut T` reference
+/// that is released to safe code, then you must not access the data within the `UnsafeCell` until
+/// that reference expires.
+///
+/// - At all times, you must avoid data races, meaning that if multiple threads have access to
+/// the same `UnsafeCell`, then any writes must have a proper happens-before relation to all other
+/// accesses (or use atomics).
 ///
+/// To assist with proper design, the following scenarios are explicitly declared legal
+/// for single-threaded code:
 ///
-/// Types like `Cell<T>` and `RefCell<T>` use this type to wrap their internal data.
+/// 1. A `&T` reference can be released to safe code and there it can co-exit with other `&T`
+/// references, but not with a `&mut T`
+///
+/// 2. A `&mut T` reference may be released to safe code, provided neither other `&mut T` nor `&T`
+/// co-exist with it. A `&mut T` must always be unique.
+///
+/// Note that while mutating or mutably aliasing the contents of an `& UnsafeCell<T>` is
+/// okay (provided you enforce the invariants some other way), it is still undefined behavior
+/// to have multiple `&mut UnsafeCell<T>` aliases.
 ///
 /// # Examples
 ///
@@ -1282,9 +1303,9 @@ impl<T: ?Sized> UnsafeCell<T> {
     /// Gets a mutable pointer to the wrapped value.
     ///
     /// This can be cast to a pointer of any kind.
-    /// Ensure that the access is unique when casting to
-    /// `&mut T`, and ensure that there are no mutations or mutable
-    /// aliases going on when casting to `&T`
+    /// Ensure that the access is unique (no active references, mutable or not)
+    /// when casting to `&mut T`, and ensure that there are no mutations
+    /// or mutable aliases going on when casting to `&T`
     ///
     /// # Examples
     ///
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 8ad5a9861a0..213b317f632 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -684,18 +684,16 @@ pub trait Octal {
 ///
 /// The `Binary` trait should format its output as a number in binary.
 ///
-/// For primitive signed integers (`i8` to `i128`, and `isize`),
+/// For primitive signed integers ([`i8`] to [`i128`], and [`isize`]),
 /// negative values are formatted as the two’s complement representation.
 ///
 /// The alternate flag, `#`, adds a `0b` in front of the output.
 ///
 /// For more information on formatters, see [the module-level documentation][module].
 ///
-/// [module]: ../../std/fmt/index.html
-///
 /// # Examples
 ///
-/// Basic usage with `i32`:
+/// Basic usage with [`i32`]:
 ///
 /// ```
 /// let x = 42; // 42 is '101010' in binary
@@ -725,6 +723,12 @@ pub trait Octal {
 ///
 /// println!("l as binary is: {:b}", l);
 /// ```
+///
+/// [module]: ../../std/fmt/index.html
+/// [`i8`]: ../../std/primitive.i8.html
+/// [`i128`]: ../../std/primitive.i128.html
+/// [`isize`]: ../../std/primitive.isize.html
+/// [`i32`]: ../../std/primitive.i32.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Binary {
     /// Formats the value using the given formatter.
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 1efd605112d..448e49ffebd 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -74,7 +74,9 @@
 #![feature(concat_idents)]
 #![feature(const_fn)]
 #![feature(custom_attribute)]
+#![feature(doc_cfg)]
 #![feature(doc_spotlight)]
+#![feature(fn_must_use)]
 #![feature(fundamental)]
 #![feature(i128_type)]
 #![feature(inclusive_range_syntax)]
diff --git a/src/librustc_back/target/l4re_base.rs b/src/librustc_back/target/l4re_base.rs
index 7cb7f8d613d..3b13ef01500 100644
--- a/src/librustc_back/target/l4re_base.rs
+++ b/src/librustc_back/target/l4re_base.rs
@@ -8,74 +8,35 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use PanicStrategy;
 use LinkerFlavor;
+use PanicStrategy;
 use target::{LinkArgs, TargetOptions};
 use std::default::Default;
-use std::env;
-use std::process::Command;
+//use std::process::Command;
 
 // Use GCC to locate code for crt* libraries from the host, not from L4Re. Note
 // that a few files also come from L4Re, for these, the function shouldn't be
 // used. This uses GCC for the location of the file, but GCC is required for L4Re anyway.
-fn get_path_or(filename: &str) -> String {
-    let child = Command::new("gcc")
-        .arg(format!("-print-file-name={}", filename)).output()
-        .expect("Failed to execute GCC");
-    String::from_utf8(child.stdout)
-        .expect("Couldn't read path from GCC").trim().into()
-}
+//fn get_path_or(filename: &str) -> String {
+//    let child = Command::new("gcc")
+//        .arg(format!("-print-file-name={}", filename)).output()
+//        .expect("Failed to execute GCC");
+//    String::from_utf8(child.stdout)
+//        .expect("Couldn't read path from GCC").trim().into()
+//}
 
-pub fn opts() -> Result<TargetOptions, String> {
-    let l4re_lib_path = env::var_os("L4RE_LIBDIR").ok_or("Unable to find L4Re \
-        library directory: L4RE_LIBDIR not set.")?.into_string().unwrap();
-    let mut pre_link_args = LinkArgs::new();
-    pre_link_args.insert(LinkerFlavor::Ld, vec![
-        format!("-T{}/main_stat.ld", l4re_lib_path),
-        "--defsym=__executable_start=0x01000000".to_string(),
-        "--defsym=__L4_KIP_ADDR__=0x6ffff000".to_string(),
-        format!("{}/crt1.o", l4re_lib_path),
-        format!("{}/crti.o", l4re_lib_path),
-        get_path_or("crtbeginT.o"),
-    ]);
-    let mut post_link_args = LinkArgs::new();
-    post_link_args.insert(LinkerFlavor::Ld, vec![
-        format!("{}/l4f/libpthread.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_sig.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_sig_noop.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_socket_noop.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_fs_noop.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_sem_noop.a", l4re_lib_path),
-        format!("{}/l4f/libl4re-vfs.o.a", l4re_lib_path),
-        format!("{}/l4f/lib4re.a", l4re_lib_path),
-        format!("{}/l4f/lib4re-util.a", l4re_lib_path),
-        format!("{}/l4f/libc_support_misc.a", l4re_lib_path),
-        format!("{}/l4f/libsupc++.a", l4re_lib_path),
-        format!("{}/l4f/lib4shmc.a", l4re_lib_path),
-        format!("{}/l4f/lib4re-c.a", l4re_lib_path),
-        format!("{}/l4f/lib4re-c-util.a", l4re_lib_path),
-        get_path_or("libgcc_eh.a"),
-        format!("{}/l4f/libdl.a", l4re_lib_path),
-        "--start-group".to_string(),
-        format!("{}/l4f/libl4util.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_l4re.a", l4re_lib_path),
-        format!("{}/l4f/libuc_c.a", l4re_lib_path),
-        format!("{}/l4f/libc_be_l4refile.a", l4re_lib_path),
-        "--end-group".to_string(),
-        format!("{}/l4f/libl4sys.a", l4re_lib_path),
-        "-gc-sections".to_string(),
-        get_path_or("crtend.o"),
-        format!("{}/crtn.o", l4re_lib_path),
-    ]);
+pub fn opts() -> TargetOptions {
+    let mut args = LinkArgs::new();
+    args.insert(LinkerFlavor::Gcc, vec![]);
 
-    Ok(TargetOptions {
+    TargetOptions {
         executables: true,
         has_elf_tls: false,
         exe_allocation_crate: None,
         panic_strategy: PanicStrategy::Abort,
-        pre_link_args,
-        post_link_args,
+        linker: Some("ld".to_string()),
+        pre_link_args: args,
         target_family: Some("unix".to_string()),
         .. Default::default()
-    })
+    }
 }
diff --git a/src/librustc_back/target/x86_64_unknown_l4re_uclibc.rs b/src/librustc_back/target/x86_64_unknown_l4re_uclibc.rs
index 6e849f19cf2..821a77f52f5 100644
--- a/src/librustc_back/target/x86_64_unknown_l4re_uclibc.rs
+++ b/src/librustc_back/target/x86_64_unknown_l4re_uclibc.rs
@@ -12,7 +12,7 @@ use LinkerFlavor;
 use target::{Target, TargetResult};
 
 pub fn target() -> TargetResult {
-    let mut base = super::l4re_base::opts()?;
+    let mut base = super::l4re_base::opts();
     base.cpu = "x86-64".to_string();
     base.max_atomic_width = Some(64);
 
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 19085ff039e..1ea1ff1fae2 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -3096,10 +3096,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                             };
                     }
                     ty::TyRawPtr(..) => {
-                        err.note(&format!("`{0}` is a native pointer; perhaps you need to deref \
-                                           with `(*{0}).{1}`",
-                                          self.tcx.hir.node_to_pretty_string(base.id),
-                                          field.node));
+                        let base = self.tcx.hir.node_to_pretty_string(base.id);
+                        let msg = format!("`{}` is a native pointer; try dereferencing it", base);
+                        let suggestion = format!("(*{}).{}", base, field.node);
+                        err.span_suggestion(field.span, &msg, suggestion);
                     }
                     _ => {}
                 }
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 3750faec801..678e1762a55 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -3181,14 +3181,16 @@ fn render_assoc_items(w: &mut fmt::Formatter,
         render_impls(cx, w, concrete, containing_item)?;
         write!(w, "</div>")?;
 
-        write!(w, "
-            <h2 id='synthetic-implementations' class='small-section-header'>
-              Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a>
-            </h2>
-            <div id='synthetic-implementations-list'>
-        ")?;
-        render_impls(cx, w, synthetic, containing_item)?;
-        write!(w, "</div>")?;
+        if !synthetic.is_empty() {
+            write!(w, "
+                <h2 id='synthetic-implementations' class='small-section-header'>
+                  Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a>
+                </h2>
+                <div id='synthetic-implementations-list'>
+            ")?;
+            render_impls(cx, w, synthetic, containing_item)?;
+            write!(w, "</div>")?;
+        }
     }
     Ok(())
 }
diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js
index f1c9c58a4eb..28d39cb174a 100644
--- a/src/librustdoc/html/static/main.js
+++ b/src/librustdoc/html/static/main.js
@@ -1628,6 +1628,7 @@
     function toggleAllDocs() {
         var toggle = document.getElementById("toggle-all-docs");
         if (hasClass(toggle, "will-expand")) {
+            updateLocalStorage("rustdoc-collapse", "false");
             removeClass(toggle, "will-expand");
             onEveryMatchingChild(toggle, "inner", function(e) {
                 e.innerHTML = labelForToggleButton(false);
@@ -1637,6 +1638,7 @@
                 collapseDocs(e, "show");
             });
         } else {
+            updateLocalStorage("rustdoc-collapse", "true");
             addClass(toggle, "will-expand");
             onEveryMatchingChild(toggle, "inner", function(e) {
                 e.innerHTML = labelForToggleButton(true);
@@ -1988,6 +1990,10 @@
     window.onresize = function() {
         hideSidebar();
     };
+
+    if (getCurrentValue("rustdoc-collapse") === "true") {
+        toggleAllDocs();
+    }
 }());
 
 // Sets the focus on the search bar at the top of the page
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 292a78278ab..db52ed67d3a 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -453,6 +453,10 @@ impl File {
     /// will be extended to `size` and have all of the intermediate data filled
     /// in with 0s.
     ///
+    /// The file's cursor isn't changed. In particular, if the cursor was at the
+    /// end and the file is shrunk using this operation, the cursor will now be
+    /// past the end.
+    ///
     /// # Errors
     ///
     /// This function will return an error if the file is not opened for writing.
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index f5aa01fb034..bd0ca0e6704 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2831,9 +2831,10 @@ impl<'a> Parser<'a> {
                 let (span, e) = self.interpolated_or_expr_span(e)?;
                 let span_of_tilde = lo;
                 let mut err = self.diagnostic().struct_span_err(span_of_tilde,
-                        "`~` can not be used as a unary operator");
-                err.span_label(span_of_tilde, "did you mean `!`?");
-                err.help("use `!` instead of `~` if you meant to perform bitwise negation");
+                        "`~` cannot be used as a unary operator");
+                err.span_suggestion_short(span_of_tilde,
+                                          "use `!` to perform bitwise negation",
+                                          "!".to_owned());
                 err.emit();
                 (lo.to(span), self.mk_unary(UnOp::Not, e))
             }
@@ -3389,7 +3390,7 @@ impl<'a> Parser<'a> {
                                                None)?;
         if let Err(mut e) = self.expect(&token::OpenDelim(token::Brace)) {
             if self.token == token::Token::Semi {
-                e.span_note(match_span, "did you mean to remove this `match` keyword?");
+                e.span_suggestion_short(match_span, "try removing this `match`", "".to_owned());
             }
             return Err(e)
         }
@@ -5361,7 +5362,9 @@ impl<'a> Parser<'a> {
                 if is_macro_rules {
                     let mut err = self.diagnostic()
                         .struct_span_err(sp, "can't qualify macro_rules invocation with `pub`");
-                    err.help("did you mean #[macro_export]?");
+                    err.span_suggestion(sp,
+                                        "try exporting the macro",
+                                        "#[macro_export]".to_owned());
                     Err(err)
                 } else {
                     let mut err = self.diagnostic()
diff --git a/src/libsyntax_ext/deriving/debug.rs b/src/libsyntax_ext/deriving/debug.rs
index 82fc09fca69..7b23de582a7 100644
--- a/src/libsyntax_ext/deriving/debug.rs
+++ b/src/libsyntax_ext/deriving/debug.rs
@@ -70,7 +70,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P<E
     // We want to make sure we have the ctxt set so that we can use unstable methods
     let span = span.with_ctxt(cx.backtrace());
     let name = cx.expr_lit(span, ast::LitKind::Str(ident.name, ast::StrStyle::Cooked));
-    let builder = Ident::from_str("builder");
+    let builder = Ident::from_str("__debug_trait_builder");
     let builder_expr = cx.expr_ident(span, builder.clone());
 
     let fmt = substr.nonself_args[0].clone();
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 82077bc4cd4..59d701dd0fb 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -1294,6 +1294,12 @@ fn get_concurrency() -> usize {
         // FIXME: implement
         1
     }
+
+    #[cfg(target_os = "l4re")]
+    fn num_cpus() -> usize {
+        // FIXME: implement
+        1
+    }
 }
 
 pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescAndFn> {
diff --git a/src/stdsimd b/src/stdsimd
-Subproject 678cbd325c84070c9dbe4303969fbd2734c0b4e
+Subproject ab9356f2af650815d339d77306f0d09c44d531a
diff --git a/src/test/run-pass/issue-42453.rs b/src/test/run-pass/issue-42453.rs
new file mode 100644
index 00000000000..dfe3a21961e
--- /dev/null
+++ b/src/test/run-pass/issue-42453.rs
@@ -0,0 +1,17 @@
+// Copyright 2014 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.
+
+#[derive(Debug)]
+struct builder;
+
+fn main() {
+
+}
+
diff --git a/src/test/rustdoc/empty-section.rs b/src/test/rustdoc/empty-section.rs
new file mode 100644
index 00000000000..3748313593f
--- /dev/null
+++ b/src/test/rustdoc/empty-section.rs
@@ -0,0 +1,20 @@
+// 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.
+
+#![crate_name = "foo"]
+
+#![feature(optin_builtin_traits)]
+
+pub struct Foo;
+
+// @has foo/struct.Foo.html
+// @!has - '//*[@class="synthetic-implementations"]' 'Auto Trait Implementations'
+impl !Send for Foo {}
+impl !Sync for Foo {}
diff --git a/src/test/ui/did_you_mean/issue-41679.rs b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs
index 98c909e212f..e8fd248011c 100644
--- a/src/test/ui/did_you_mean/issue-41679.rs
+++ b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let x = ~1; //~ ERROR can not be used as a unary operator
+    let x = ~1; //~ ERROR cannot be used as a unary operator
 }
diff --git a/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr
new file mode 100644
index 00000000000..f13f15f6377
--- /dev/null
+++ b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr
@@ -0,0 +1,8 @@
+error: `~` cannot be used as a unary operator
+  --> $DIR/issue-41679-tilde-bitwise-negation-attempt.rs:12:13
+   |
+LL |     let x = ~1; //~ ERROR cannot be used as a unary operator
+   |             ^ help: use `!` to perform bitwise negation
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/did_you_mean/issue-41679.stderr b/src/test/ui/did_you_mean/issue-41679.stderr
deleted file mode 100644
index c17812fc0cb..00000000000
--- a/src/test/ui/did_you_mean/issue-41679.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: `~` can not be used as a unary operator
-  --> $DIR/issue-41679.rs:12:13
-   |
-LL |     let x = ~1; //~ ERROR can not be used as a unary operator
-   |             ^ did you mean `!`?
-   |
-   = help: use `!` instead of `~` if you meant to perform bitwise negation
-
-error: aborting due to previous error
-
diff --git a/src/test/parse-fail/match-refactor-to-expr.rs b/src/test/ui/did_you_mean/match-refactor-to-expr.rs
index e2fee1d1895..3c88608697a 100644
--- a/src/test/parse-fail/match-refactor-to-expr.rs
+++ b/src/test/ui/did_you_mean/match-refactor-to-expr.rs
@@ -12,7 +12,7 @@
 
 fn main() {
     let foo =
-        match //~ NOTE did you mean to remove this `match` keyword?
+        match
         Some(4).unwrap_or_else(5)
         //~^ NOTE expected one of `.`, `?`, `{`, or an operator here
         ; //~ NOTE unexpected token
diff --git a/src/test/ui/did_you_mean/match-refactor-to-expr.stderr b/src/test/ui/did_you_mean/match-refactor-to-expr.stderr
new file mode 100644
index 00000000000..ecca781684c
--- /dev/null
+++ b/src/test/ui/did_you_mean/match-refactor-to-expr.stderr
@@ -0,0 +1,13 @@
+error: expected one of `.`, `?`, `{`, or an operator, found `;`
+  --> $DIR/match-refactor-to-expr.rs:18:9
+   |
+LL |         match
+   |         ----- help: try removing this `match`
+LL |         Some(4).unwrap_or_else(5)
+   |                                  - expected one of `.`, `?`, `{`, or an operator here
+LL |         //~^ NOTE expected one of `.`, `?`, `{`, or an operator here
+LL |         ; //~ NOTE unexpected token
+   |         ^ unexpected token
+
+error: aborting due to previous error
+
diff --git a/src/test/parse-fail/pub-macro-rules.rs b/src/test/ui/did_you_mean/pub-macro-rules.rs
index 93b992f2f8a..65a0d642cd7 100644
--- a/src/test/parse-fail/pub-macro-rules.rs
+++ b/src/test/ui/did_you_mean/pub-macro-rules.rs
@@ -9,8 +9,7 @@
 // except according to those terms.
 
 #[macro_use] mod bleh {
-    pub macro_rules! foo { //~ ERROR can't qualify macro_rules invocation with `pub`
-    //~^ HELP did you mean #[macro_export]?
+    pub macro_rules! foo { //~ ERROR can't qualify macro_rules invocation
         ($n:ident) => (
             fn $n () -> i32 {
                 1
diff --git a/src/test/ui/did_you_mean/pub-macro-rules.stderr b/src/test/ui/did_you_mean/pub-macro-rules.stderr
new file mode 100644
index 00000000000..dfeab75525b
--- /dev/null
+++ b/src/test/ui/did_you_mean/pub-macro-rules.stderr
@@ -0,0 +1,8 @@
+error: can't qualify macro_rules invocation with `pub`
+  --> $DIR/pub-macro-rules.rs:12:5
+   |
+LL |     pub macro_rules! foo { //~ ERROR can't qualify macro_rules invocation
+   |     ^^^ help: try exporting the macro: `#[macro_export]`
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/issue-11004.stderr b/src/test/ui/issue-11004.stderr
index 4cfc7d23bd0..268c3cd6d2a 100644
--- a/src/test/ui/issue-11004.stderr
+++ b/src/test/ui/issue-11004.stderr
@@ -2,17 +2,13 @@ error[E0609]: no field `x` on type `*mut A`
   --> $DIR/issue-11004.rs:17:21
    |
 LL |     let x : i32 = n.x; //~ no field `x` on type `*mut A`
-   |                     ^
-   |
-   = note: `n` is a native pointer; perhaps you need to deref with `(*n).x`
+   |                     ^ help: `n` is a native pointer; try dereferencing it: `(*n).x`
 
 error[E0609]: no field `y` on type `*mut A`
   --> $DIR/issue-11004.rs:18:21
    |
 LL |     let y : f64 = n.y; //~ no field `y` on type `*mut A`
-   |                     ^
-   |
-   = note: `n` is a native pointer; perhaps you need to deref with `(*n).y`
+   |                     ^ help: `n` is a native pointer; try dereferencing it: `(*n).y`
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/lifetime-errors/ex3-both-anon-regions-4.stderr b/src/test/ui/lifetime-errors/ex3-both-anon-regions-4.stderr
deleted file mode 100644
index 19339800a7a..00000000000
--- a/src/test/ui/lifetime-errors/ex3-both-anon-regions-4.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0623]: lifetime mismatch
-  --> $DIR/ex3-both-anon-regions-4.rs:12:13
-   |
-11 | fn foo(z: &mut Vec<(&u8,&u8)>, (x, y): (&u8, &u8)) {
-   |                     ---                 --- these references are declared with different lifetimes...
-12 |     z.push((x,y));
-   |             ^ ...but data flows into `z` here
-
-error[E0623]: lifetime mismatch
-  --> $DIR/ex3-both-anon-regions-4.rs:12:15
-   |
-11 | fn foo(z: &mut Vec<(&u8,&u8)>, (x, y): (&u8, &u8)) {
-   |                         ---                  --- these references are declared with different lifetimes...
-12 |     z.push((x,y));
-   |               ^ ...but data flows into `z` here
-
-error: aborting due to 2 previous errors
-
-If you want more information on this error, try using "rustc --explain E0623"
diff --git a/src/test/ui/nll/closure-requirements/propagate-approximated-to-empty.stderr b/src/test/ui/nll/closure-requirements/propagate-approximated-to-empty.stderr
deleted file mode 100644
index 502b344c89e..00000000000
--- a/src/test/ui/nll/closure-requirements/propagate-approximated-to-empty.stderr
+++ /dev/null
@@ -1,45 +0,0 @@
-warning: not reporting region error due to -Znll
-  --> $DIR/propagate-approximated-to-empty.rs:41:9
-   |
-41 |         demand_y(x, y, x.get())
-   |         ^^^^^^^^^^^^^^^^^^^^^^^
-
-error: free region `'_#6r` does not outlive free region `'_#4r`
-  --> $DIR/propagate-approximated-to-empty.rs:41:18
-   |
-41 |         demand_y(x, y, x.get())
-   |                  ^
-
-note: No external requirements
-  --> $DIR/propagate-approximated-to-empty.rs:39:47
-   |
-39 |       establish_relationships(&cell_a, &cell_b, |_outlives, x, y| {
-   |  _______________________________________________^
-40 | |         // Only works if 'x: 'y:
-41 | |         demand_y(x, y, x.get())
-42 | |         //~^ WARN not reporting region error due to -Znll
-43 | |         //~| ERROR free region `'_#6r` does not outlive free region `'_#4r`
-44 | |     });
-   | |_____^
-   |
-   = note: defining type: DefId(0/1:18 ~ propagate_approximated_to_empty[317d]::supply[0]::{{closure}}[0]) with closure substs [
-               i16,
-               for<'r, 's, 't0, 't1, 't2> extern "rust-call" fn((&ReLateBound(DebruijnIndex { depth: 1 }, BrNamed(crate0:DefIndex(0:0), 'r)) std::cell::Cell<&ReLateBound(DebruijnIndex { depth: 1 }, BrNamed(crate0:DefIndex(0:0), 's)) &'_#1r u32>, &ReLateBound(DebruijnIndex { depth: 1 }, BrNamed(crate0:DefIndex(0:0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex { depth: 1 }, BrNamed(crate0:DefIndex(0:0), 't1)) u32>, &ReLateBound(DebruijnIndex { depth: 1 }, BrNamed(crate0:DefIndex(0:0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex { depth: 1 }, BrNamed(crate0:DefIndex(0:0), 's)) u32>))
-           ]
-
-note: No external requirements
-  --> $DIR/propagate-approximated-to-empty.rs:38:1
-   |
-38 | / fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
-39 | |     establish_relationships(&cell_a, &cell_b, |_outlives, x, y| {
-40 | |         // Only works if 'x: 'y:
-41 | |         demand_y(x, y, x.get())
-...  |
-44 | |     });
-45 | | }
-   | |_^
-   |
-   = note: defining type: DefId(0/0:6 ~ propagate_approximated_to_empty[317d]::supply[0]) with substs []
-
-error: aborting due to previous error
-
diff --git a/src/test/ui/resolve-error.stderr b/src/test/ui/resolve-error.stderr
deleted file mode 100644
index 27f93939246..00000000000
--- a/src/test/ui/resolve-error.stderr
+++ /dev/null
@@ -1,62 +0,0 @@
-error: cannot find derive macro `FooWithLongNan` in this scope
-  --> $DIR/resolve-error.rs:37:10
-   |
-37 | #[derive(FooWithLongNan)]
-   |          ^^^^^^^^^^^^^^ help: try: `FooWithLongName`
-
-error: cannot find attribute macro `attr_proc_macra` in this scope
-  --> $DIR/resolve-error.rs:40:3
-   |
-40 | #[attr_proc_macra]
-   |   ^^^^^^^^^^^^^^^ help: try: `attr_proc_macro`
-
-error: cannot find attribute macro `FooWithLongNan` in this scope
-  --> $DIR/resolve-error.rs:43:3
-   |
-43 | #[FooWithLongNan]
-   |   ^^^^^^^^^^^^^^
-
-error: cannot find derive macro `Dlone` in this scope
-  --> $DIR/resolve-error.rs:46:10
-   |
-46 | #[derive(Dlone)]
-   |          ^^^^^ help: try: `Clone`
-
-error: cannot find derive macro `Dlona` in this scope
-  --> $DIR/resolve-error.rs:49:10
-   |
-49 | #[derive(Dlona)]
-   |          ^^^^^ help: try: `Clona`
-
-error: cannot find derive macro `attr_proc_macra` in this scope
-  --> $DIR/resolve-error.rs:52:10
-   |
-52 | #[derive(attr_proc_macra)]
-   |          ^^^^^^^^^^^^^^^
-
-error: cannot find macro `FooWithLongNama!` in this scope
-  --> $DIR/resolve-error.rs:56:5
-   |
-56 |     FooWithLongNama!();
-   |     ^^^^^^^^^^^^^^^ help: you could try the macro: `FooWithLongNam!`
-
-error: cannot find macro `attr_proc_macra!` in this scope
-  --> $DIR/resolve-error.rs:58:5
-   |
-58 |     attr_proc_macra!();
-   |     ^^^^^^^^^^^^^^^ help: you could try the macro: `attr_proc_mac!`
-
-error: cannot find macro `Dlona!` in this scope
-  --> $DIR/resolve-error.rs:60:5
-   |
-60 |     Dlona!();
-   |     ^^^^^
-
-error: cannot find macro `bang_proc_macrp!` in this scope
-  --> $DIR/resolve-error.rs:62:5
-   |
-62 |     bang_proc_macrp!();
-   |     ^^^^^^^^^^^^^^^ help: you could try the macro: `bang_proc_macro!`
-
-error: aborting due to previous error(s)
-
diff --git a/src/test/ui/span/loan-extend.stderr b/src/test/ui/span/loan-extend.stderr
deleted file mode 100644
index af498129fc4..00000000000
--- a/src/test/ui/span/loan-extend.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0597]: `short` does not live long enough
-  --> $DIR/loan-extend.rs:21:1
-   |
-19 |     long = borrow(&mut short);
-   |                        ----- borrow occurs here
-20 |
-21 | }
-   | ^ `short` dropped here while still borrowed
-   |
-   = note: values in a scope are dropped in the opposite order they are created
-
-error: aborting due to previous error
-
-If you want more information on this error, try using "rustc --explain E0597"
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index c927ff19b27..06eb055f68e 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -51,6 +51,7 @@ pub mod features;
 pub mod cargo;
 pub mod pal;
 pub mod deps;
+pub mod ui_tests;
 pub mod unstable_book;
 
 fn filter_dirs(path: &Path) -> bool {
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index afa3ebd1983..24974192795 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -45,6 +45,7 @@ fn main() {
         deps::check(&path, &mut bad);
     }
     deps::check_whitelist(&path, &cargo, &mut bad);
+    ui_tests::check(&path, &mut bad);
 
     if bad {
         eprintln!("some tidy checks failed");
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
new file mode 100644
index 00000000000..f7fec2e667a
--- /dev/null
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -0,0 +1,26 @@
+// Copyright 2018 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.
+
+//! Tidy check to ensure that there are no stray `.stderr` files in UI test directories.
+
+use std::path::Path;
+
+pub fn check(path: &Path, bad: &mut bool) {
+    super::walk_many(&[&path.join("test/ui"), &path.join("test/ui-fulldeps")],
+                     &mut |_| false,
+                     &mut |file_path| {
+        if let Some(ext) = file_path.extension() {
+            if (ext == "stderr" || ext == "stdout") && !file_path.with_extension("rs").exists() {
+                println!("Stray file with UI testing output: {:?}", file_path);
+                *bad = true;
+            }
+        }
+    });
+}