Auto merge of #52735 - Mark-Simulacrum:rollup, r=Mark-Simulacrum

Rollup of 16 pull requests

Successful merges:

 - #52558 (Add tests for ICEs which no longer repro)
 - #52610 (Clarify what a task is)
 - #52617 (Don't match on region kinds when reporting NLL errors)
 - #52635 (Fix #[linkage] propagation though generic functions)
 - #52647 (Suggest to take and ignore args while closure args count mismatching)
 - #52649 (Point spans to inner elements of format strings)
 - #52654 (Format linker args in a way that works for gcc and ld)
 - #52667 (update the stdsimd submodule)
 - #52674 (Impl Executor for Box<E: Executor>)
 - #52690 (ARM: expose `rclass` and `dsp` target features)
 - #52692 (Improve readability in a few sorts)
 - #52695 (Hide some lints which are not quite right the way they are reported to the user)
 - #52718 (State default capacity for BufReader/BufWriter)
 - #52721 (std::ops::Try impl for std::task::Poll)
 - #52723 (rustc: Register crates under their real names)
 - #52734 (sparc ABI issue - structure returning from function is returned in 64bit registers (with tests))

Failed merges:

 - #52678 ([NLL] Use better spans in some errors)

r? @ghost

src/liballoc/boxed.rs

@@ -67,7 +67,7 @@ use core::marker::{Unpin, Unsize};
 use core::mem::{self, PinMut};
 use core::ops::{CoerceUnsized, Deref, DerefMut, Generator, GeneratorState};
 use core::ptr::{self, NonNull, Unique};
-use core::task::{Context, Poll};
+use core::task::{Context, Poll, Executor, SpawnErrorKind, SpawnObjError};
 
 use raw_vec::RawVec;
 use str::from_boxed_utf8_unchecked;
@@ -972,6 +972,19 @@ unsafe impl<'a, T, F> UnsafeFutureObj<'a, T> for PinBox<F>
     }
 }
 
+#[unstable(feature = "futures_api", issue = "50547")]
+impl<E> Executor for Box<E>
+    where E: Executor + ?Sized
+{
+    fn spawn_obj(&mut self, task: FutureObj<'static, ()>) -> Result<(), SpawnObjError> {
+        (**self).spawn_obj(task)
+    }
+
+    fn status(&self) -> Result<(), SpawnErrorKind> {
+        (**self).status()
+    }
+}
+
 #[unstable(feature = "futures_api", issue = "50547")]
 impl<'a, F: Future<Output = ()> + Send + 'a> From<PinBox<F>> for FutureObj<'a, ()> {
     fn from(boxed: PinBox<F>) -> Self {

src/libcore/task/executor.rs

@@ -17,21 +17,27 @@ use future::{FutureObj, LocalFutureObj};
 
 /// A task executor.
 ///
-/// A *task* is a `()`-producing async value that runs at the top level, and will
+/// Futures are polled until completion by tasks, a kind of lightweight
-/// be `poll`ed until completion. It's also the unit at which wake-up
+/// "thread". A *task executor* is responsible for the creation of these tasks
-/// notifications occur. Executors, such as thread pools, allow tasks to be
+/// and the coordination of their execution on real operating system threads. In
-/// spawned and are responsible for putting tasks onto ready queues when
+/// particular, whenever a task signals that it can make further progress via a
-/// they are woken up, and polling them when they are ready.
+/// wake-up notification, it is the responsibility of the task executor to put
+/// the task into a queue to continue executing it, i.e. polling the future in
+/// it, later.
 pub trait Executor {
-    /// Spawn the given task, polling it until completion.
+    /// Spawns a new task with the given future. The future will be polled until
+    /// completion.
     ///
     /// # Errors
     ///
     /// The executor may be unable to spawn tasks, either because it has
     /// been shut down or is resource-constrained.
-    fn spawn_obj(&mut self, task: FutureObj<'static, ()>) -> Result<(), SpawnObjError>;
+    fn spawn_obj(
+        &mut self,
+        future: FutureObj<'static, ()>,
+    ) -> Result<(), SpawnObjError>;
 
-    /// Determine whether the executor is able to spawn new tasks.
+    /// Determines whether the executor is able to spawn new tasks.
     ///
     /// # Returns
     ///
@@ -75,8 +81,8 @@ pub struct SpawnObjError {
     /// The kind of error
     pub kind: SpawnErrorKind,
 
-    /// The task for which spawning was attempted
+    /// The future for which spawning inside a task was attempted
-    pub task: FutureObj<'static, ()>,
+    pub future: FutureObj<'static, ()>,
 }
 
 /// The result of a failed spawn
@@ -85,6 +91,6 @@ pub struct SpawnLocalObjError {
     /// The kind of error
     pub kind: SpawnErrorKind,
 
-    /// The task for which spawning was attempted
+    /// The future for which spawning inside a task was attempted
-    pub task: LocalFutureObj<'static, ()>,
+    pub future: LocalFutureObj<'static, ()>,
 }

src/libcore/task/poll.rs

@@ -12,6 +12,9 @@
             reason = "futures in libcore are unstable",
             issue = "50547")]
 
+use ops::Try;
+use result::Result;
+
 /// Indicates whether a value is available or if the current task has been
 /// scheduled to receive a wakeup instead.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -39,6 +42,7 @@ impl<T> Poll<T> {
     }
 
     /// Returns whether this is `Poll::Ready`
+    #[inline]
     pub fn is_ready(&self) -> bool {
         match *self {
             Poll::Ready(_) => true,
@@ -47,6 +51,7 @@ impl<T> Poll<T> {
     }
 
     /// Returns whether this is `Poll::Pending`
+    #[inline]
     pub fn is_pending(&self) -> bool {
         !self.is_ready()
     }
@@ -81,3 +86,52 @@ impl<T> From<T> for Poll<T> {
         Poll::Ready(t)
     }
 }
+
+impl<T, E> Try for Poll<Result<T, E>> {
+    type Ok = Poll<T>;
+    type Error = E;
+
+    #[inline]
+    fn into_result(self) -> Result<Self::Ok, Self::Error> {
+        match self {
+            Poll::Ready(Ok(x)) => Ok(Poll::Ready(x)),
+            Poll::Ready(Err(e)) => Err(e),
+            Poll::Pending => Ok(Poll::Pending),
+        }
+    }
+
+    #[inline]
+    fn from_error(e: Self::Error) -> Self {
+        Poll::Ready(Err(e))
+    }
+
+    #[inline]
+    fn from_ok(x: Self::Ok) -> Self {
+        x.map(Ok)
+    }
+}
+
+impl<T, E> Try for Poll<Option<Result<T, E>>> {
+    type Ok = Poll<Option<T>>;
+    type Error = E;
+
+    #[inline]
+    fn into_result(self) -> Result<Self::Ok, Self::Error> {
+        match self {
+            Poll::Ready(Some(Ok(x))) => Ok(Poll::Ready(Some(x))),
+            Poll::Ready(Some(Err(e))) => Err(e),
+            Poll::Ready(None) => Ok(Poll::Ready(None)),
+            Poll::Pending => Ok(Poll::Pending),
+        }
+    }
+
+    #[inline]
+    fn from_error(e: Self::Error) -> Self {
+        Poll::Ready(Some(Err(e)))
+    }
+
+    #[inline]
+    fn from_ok(x: Self::Ok) -> Self {
+        x.map(|x| x.map(Ok))
+    }
+}

src/libfmt_macros/lib.rs

@@ -154,6 +154,8 @@ pub struct Parser<'a> {
     style: Option<usize>,
     /// How many newlines have been seen in the string so far, to adjust the error spans
     seen_newlines: usize,
+    /// Start and end byte offset of every successfuly parsed argument
+    pub arg_places: Vec<(usize, usize)>,
 }
 
 impl<'a> Iterator for Parser<'a> {
@@ -168,9 +170,13 @@ impl<'a> Iterator for Parser<'a> {
                     if self.consume('{') {
                         Some(String(self.string(pos + 1)))
                     } else {
-                        let ret = Some(NextArgument(self.argument()));
+                        let mut arg = self.argument();
-                        self.must_consume('}');
+                        if let Some(arg_pos) = self.must_consume('}').map(|end| {
-                        ret
+                            (pos + raw + 1, end + raw + 2)
+                        }) {
+                            self.arg_places.push(arg_pos);
+                        }
+                        Some(NextArgument(arg))
                     }
                 }
                 '}' => {
@@ -211,6 +217,7 @@ impl<'a> Parser<'a> {
             curarg: 0,
             style,
             seen_newlines: 0,
+            arg_places: vec![],
         }
     }
 
@@ -271,7 +278,7 @@ impl<'a> Parser<'a> {
 
     /// Forces consumption of the specified character. If the character is not
     /// found, an error is emitted.
-    fn must_consume(&mut self, c: char) {
+    fn must_consume(&mut self, c: char) -> Option<usize> {
         self.ws();
         let raw = self.style.unwrap_or(0);
 
@@ -279,12 +286,14 @@ impl<'a> Parser<'a> {
         if let Some(&(pos, maybe)) = self.cur.peek() {
             if c == maybe {
                 self.cur.next();
+                Some(pos)
             } else {
                 let pos = pos + padding + 1;
                 self.err(format!("expected `{:?}`, found `{:?}`", c, maybe),
                          format!("expected `{}`", c),
                          pos,
                          pos);
+                None
             }
         } else {
             let msg = format!("expected `{:?}` but string was terminated", c);
@@ -302,6 +311,7 @@ impl<'a> Parser<'a> {
             } else {
                 self.err(msg, format!("expected `{:?}`", c), pos, pos);
             }
+            None
         }
     }
 

src/librustc/traits/error_reporting.rs

@@ -1050,6 +1050,30 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         if let Some(found_span) = found_span {
             err.span_label(found_span, format!("takes {}", found_str));
 
+            // Suggest to take and ignore the arguments with expected_args_length `_`s if
+            // found arguments is empty (assume the user just wants to ignore args in this case).
+            // For example, if `expected_args_length` is 2, suggest `|_, _|`.
+            if found_args.is_empty() && is_closure {
+                let mut underscores = "_".repeat(expected_args.len())
+                                      .split("")
+                                      .filter(|s| !s.is_empty())
+                                      .collect::<Vec<_>>()
+                                      .join(", ");
+                err.span_suggestion_with_applicability(
+                    found_span,
+                    &format!(
+                        "consider changing the closure to take and ignore the expected argument{}",
+                        if expected_args.len() < 2 {
+                            ""
+                        } else {
+                            "s"
+                        }
+                    ),
+                    format!("|{}|", underscores),
+                    Applicability::MachineApplicable,
+                );
+            }
+
             if let &[ArgKind::Tuple(_, ref fields)] = &found_args[..] {
                 if fields.len() == expected_args.len() {
                     let sugg = fields.iter()

src/librustc_codegen_llvm/back/linker.rs

@@ -218,8 +218,10 @@ impl<'a> GccLinker<'a> {
 }
 
 impl<'a> Linker for GccLinker<'a> {
-    fn link_dylib(&mut self, lib: &str) { self.hint_dynamic(); self.cmd.arg("-l").arg(lib); }
+    fn link_dylib(&mut self, lib: &str) { self.hint_dynamic(); self.cmd.arg(format!("-l{}",lib)); }
-    fn link_staticlib(&mut self, lib: &str) { self.hint_static(); self.cmd.arg("-l").arg(lib); }
+    fn link_staticlib(&mut self, lib: &str) {
+        self.hint_static(); self.cmd.arg(format!("-l{}",lib));
+    }
     fn link_rlib(&mut self, lib: &Path) { self.hint_static(); self.cmd.arg(lib); }
     fn include_path(&mut self, path: &Path) { self.cmd.arg("-L").arg(path); }
     fn framework_path(&mut self, path: &Path) { self.cmd.arg("-F").arg(path); }
@@ -227,15 +229,15 @@ impl<'a> Linker for GccLinker<'a> {
     fn add_object(&mut self, path: &Path) { self.cmd.arg(path); }
     fn position_independent_executable(&mut self) { self.cmd.arg("-pie"); }
     fn no_position_independent_executable(&mut self) { self.cmd.arg("-no-pie"); }
-    fn full_relro(&mut self) { self.linker_arg("-z,relro,-z,now"); }
+    fn full_relro(&mut self) { self.linker_arg("-zrelro"); self.linker_arg("-znow"); }
-    fn partial_relro(&mut self) { self.linker_arg("-z,relro"); }
+    fn partial_relro(&mut self) { self.linker_arg("-zrelro"); }
-    fn no_relro(&mut self) { self.linker_arg("-z,norelro"); }
+    fn no_relro(&mut self) { self.linker_arg("-znorelro"); }
     fn build_static_executable(&mut self) { self.cmd.arg("-static"); }
     fn args(&mut self, args: &[String]) { self.cmd.args(args); }
 
     fn link_rust_dylib(&mut self, lib: &str, _path: &Path) {
         self.hint_dynamic();
-        self.cmd.arg("-l").arg(lib);
+        self.cmd.arg(format!("-l{}",lib));
     }
 
     fn link_framework(&mut self, framework: &str) {
@@ -253,23 +255,22 @@ impl<'a> Linker for GccLinker<'a> {
         self.hint_static();
         let target = &self.sess.target.target;
         if !target.options.is_like_osx {
-            self.linker_arg("--whole-archive").cmd.arg("-l").arg(lib);
+            self.linker_arg("--whole-archive").cmd.arg(format!("-l{}",lib));
             self.linker_arg("--no-whole-archive");
         } else {
             // -force_load is the macOS equivalent of --whole-archive, but it
             // involves passing the full path to the library to link.
-            let mut v = OsString::from("-force_load,");
+            self.linker_arg("-force_load");
-            v.push(&archive::find_library(lib, search_path, &self.sess));
+            let lib = archive::find_library(lib, search_path, &self.sess);
-            self.linker_arg(&v);
+            self.linker_arg(&lib);
         }
     }
 
     fn link_whole_rlib(&mut self, lib: &Path) {
         self.hint_static();
         if self.sess.target.target.options.is_like_osx {
-            let mut v = OsString::from("-force_load,");
+            self.linker_arg("-force_load");
-            v.push(lib);
+            self.linker_arg(&lib);
-            self.linker_arg(&v);
         } else {
             self.linker_arg("--whole-archive").cmd.arg(lib);
             self.linker_arg("--no-whole-archive");
@@ -294,8 +295,7 @@ impl<'a> Linker for GccLinker<'a> {
         if self.sess.target.target.options.is_like_osx {
             self.linker_arg("-dead_strip");
         } else if self.sess.target.target.options.is_like_solaris {
-            self.linker_arg("-z");
+            self.linker_arg("-zignore");
-            self.linker_arg("ignore");
 
         // If we're building a dylib, we don't use --gc-sections because LLVM
         // has already done the best it can do, and we also don't want to
@@ -369,7 +369,8 @@ impl<'a> Linker for GccLinker<'a> {
             // the right `-Wl,-install_name` with an `@rpath` in it.
             if self.sess.opts.cg.rpath ||
                self.sess.opts.debugging_opts.osx_rpath_install_name {
-                let mut v = OsString::from("-install_name,@rpath/");
+                self.linker_arg("-install_name");
+                let mut v = OsString::from("@rpath/");
                 v.push(out_filename.file_name().unwrap());
                 self.linker_arg(&v);
             }
@@ -448,7 +449,8 @@ impl<'a> Linker for GccLinker<'a> {
     }
 
     fn subsystem(&mut self, subsystem: &str) {
-        self.linker_arg(&format!("--subsystem,{}", subsystem));
+        self.linker_arg("--subsystem");
+        self.linker_arg(&subsystem);
     }
 
     fn finalize(&mut self) -> Command {

src/librustc_codegen_llvm/consts.rs

@@ -20,12 +20,14 @@ use monomorphize::MonoItem;
 use common::{CodegenCx, val_ty};
 use declare;
 use monomorphize::Instance;
+use syntax_pos::Span;
+use syntax_pos::symbol::LocalInternedString;
 use type_::Type;
 use type_of::LayoutLlvmExt;
-use rustc::ty;
+use rustc::ty::{self, Ty};
 use rustc::ty::layout::{Align, LayoutOf};
 
-use rustc::hir::{self, CodegenFnAttrFlags};
+use rustc::hir::{self, CodegenFnAttrs, CodegenFnAttrFlags};
 
 use std::ffi::{CStr, CString};
 
@@ -119,6 +121,8 @@ pub fn get_static(cx: &CodegenCx, def_id: DefId) -> ValueRef {
     let ty = instance.ty(cx.tcx);
     let sym = cx.tcx.symbol_name(instance).as_str();
 
+    debug!("get_static: sym={} instance={:?}", sym, instance);
+
     let g = if let Some(id) = cx.tcx.hir.as_local_node_id(def_id) {
 
         let llty = cx.layout_of(ty).llvm_type(cx);
@@ -144,50 +148,15 @@ pub fn get_static(cx: &CodegenCx, def_id: DefId) -> ValueRef {
             hir_map::NodeForeignItem(&hir::ForeignItem {
                 ref attrs, span, node: hir::ForeignItemKind::Static(..), ..
             }) => {
-                let g = if let Some(linkage) = cx.tcx.codegen_fn_attrs(def_id).linkage {
+                let fn_attrs = cx.tcx.codegen_fn_attrs(def_id);
-                    // If this is a static with a linkage specified, then we need to handle
+                (check_and_apply_linkage(cx, &fn_attrs, ty, sym, Some(span)), attrs)
-                    // it a little specially. The typesystem prevents things like &T and
-                    // extern "C" fn() from being non-null, so we can't just declare a
-                    // static and call it a day. Some linkages (like weak) will make it such
-                    // that the static actually has a null value.
-                    let llty2 = match ty.sty {
-                        ty::TyRawPtr(ref mt) => cx.layout_of(mt.ty).llvm_type(cx),
-                        _ => {
-                            cx.sess().span_fatal(span, "must have type `*const T` or `*mut T`");
-                        }
-                    };
-                    unsafe {
-                        // Declare a symbol `foo` with the desired linkage.
-                        let g1 = declare::declare_global(cx, &sym, llty2);
-                        llvm::LLVMRustSetLinkage(g1, base::linkage_to_llvm(linkage));
-
-                        // Declare an internal global `extern_with_linkage_foo` which
-                        // is initialized with the address of `foo`.  If `foo` is
-                        // discarded during linking (for example, if `foo` has weak
-                        // linkage and there are no definitions), then
-                        // `extern_with_linkage_foo` will instead be initialized to
-                        // zero.
-                        let mut real_name = "_rust_extern_with_linkage_".to_string();
-                        real_name.push_str(&sym);
-                        let g2 = declare::define_global(cx, &real_name, llty).unwrap_or_else(||{
-                            cx.sess().span_fatal(span,
-                                &format!("symbol `{}` is already defined", &sym))
-                        });
-                        llvm::LLVMRustSetLinkage(g2, llvm::Linkage::InternalLinkage);
-                        llvm::LLVMSetInitializer(g2, g1);
-                        g2
-                    }
-                } else {
-                    // Generate an external declaration.
-                    declare::declare_global(cx, &sym, llty)
-                };
-
-                (g, attrs)
             }
 
             item => bug!("get_static: expected static, found {:?}", item)
         };
 
+        debug!("get_static: sym={} attrs={:?}", sym, attrs);
+
         for attr in attrs {
             if attr.check_name("thread_local") {
                 llvm::set_thread_local_mode(g, cx.tls_model);
@@ -197,19 +166,21 @@ pub fn get_static(cx: &CodegenCx, def_id: DefId) -> ValueRef {
         g
     } else {
         // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
-        // FIXME(nagisa): investigate whether it can be changed into define_global
+        debug!("get_static: sym={} item_attr={:?}", sym, cx.tcx.item_attrs(def_id));
-        let g = declare::declare_global(cx, &sym, cx.layout_of(ty).llvm_type(cx));
+
+        let attrs = cx.tcx.codegen_fn_attrs(def_id);
+        let g = check_and_apply_linkage(cx, &attrs, ty, sym, None);
+
         // Thread-local statics in some other crate need to *always* be linked
         // against in a thread-local fashion, so we need to be sure to apply the
         // thread-local attribute locally if it was present remotely. If we
         // don't do this then linker errors can be generated where the linker
         // complains that one object files has a thread local version of the
         // symbol and another one doesn't.
-        for attr in cx.tcx.get_attrs(def_id).iter() {
+        if attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
-            if attr.check_name("thread_local") {
             llvm::set_thread_local_mode(g, cx.tls_model);
         }
-        }
+
         if cx.use_dll_storage_attrs && !cx.tcx.is_foreign_item(def_id) {
             // This item is external but not foreign, i.e. it originates from an external Rust
             // crate. Since we don't know whether this crate will be linked dynamically or
@@ -242,6 +213,66 @@ pub fn get_static(cx: &CodegenCx, def_id: DefId) -> ValueRef {
     g
 }
 
+fn check_and_apply_linkage<'tcx>(
+    cx: &CodegenCx<'_, 'tcx>,
+    attrs: &CodegenFnAttrs,
+    ty: Ty<'tcx>,
+    sym: LocalInternedString,
+    span: Option<Span>
+) -> ValueRef {
+    let llty = cx.layout_of(ty).llvm_type(cx);
+    if let Some(linkage) = attrs.linkage {
+        debug!("get_static: sym={} linkage={:?}", sym, linkage);
+
+        // If this is a static with a linkage specified, then we need to handle
+        // it a little specially. The typesystem prevents things like &T and
+        // extern "C" fn() from being non-null, so we can't just declare a
+        // static and call it a day. Some linkages (like weak) will make it such
+        // that the static actually has a null value.
+        let llty2 = match ty.sty {
+            ty::TyRawPtr(ref mt) => cx.layout_of(mt.ty).llvm_type(cx),
+            _ => {
+                if span.is_some() {
+                    cx.sess().span_fatal(span.unwrap(), "must have type `*const T` or `*mut T`")
+                } else {
+                    bug!("must have type `*const T` or `*mut T`")
+                }
+            }
+        };
+        unsafe {
+            // Declare a symbol `foo` with the desired linkage.
+            let g1 = declare::declare_global(cx, &sym, llty2);
+            llvm::LLVMRustSetLinkage(g1, base::linkage_to_llvm(linkage));
+
+            // Declare an internal global `extern_with_linkage_foo` which
+            // is initialized with the address of `foo`.  If `foo` is
+            // discarded during linking (for example, if `foo` has weak
+            // linkage and there are no definitions), then
+            // `extern_with_linkage_foo` will instead be initialized to
+            // zero.
+            let mut real_name = "_rust_extern_with_linkage_".to_string();
+            real_name.push_str(&sym);
+            let g2 = declare::define_global(cx, &real_name, llty).unwrap_or_else(||{
+                if span.is_some() {
+                    cx.sess().span_fatal(
+                        span.unwrap(),
+                        &format!("symbol `{}` is already defined", &sym)
+                    )
+                } else {
+                    bug!("symbol `{}` is already defined", &sym)
+                }
+            });
+            llvm::LLVMRustSetLinkage(g2, llvm::Linkage::InternalLinkage);
+            llvm::LLVMSetInitializer(g2, g1);
+            g2
+        }
+    } else {
+        // Generate an external declaration.
+        // FIXME(nagisa): investigate whether it can be changed into define_global
+        declare::declare_global(cx, &sym, llty)
+    }
+}
+
 pub fn codegen_static<'a, 'tcx>(
     cx: &CodegenCx<'a, 'tcx>,
     def_id: DefId,

src/librustc_codegen_llvm/llvm_util.rs

@@ -85,6 +85,8 @@ unsafe fn configure_llvm(sess: &Session) {
 
 const ARM_WHITELIST: &[(&str, Option<&str>)] = &[
     ("mclass", Some("arm_target_feature")),
+    ("rclass", Some("arm_target_feature")),
+    ("dsp", Some("arm_target_feature")),
     ("neon", Some("arm_target_feature")),
     ("v7", Some("arm_target_feature")),
     ("vfp2", Some("arm_target_feature")),

src/librustc_driver/lib.rs

@@ -1229,10 +1229,7 @@ Available lint options:
     fn sort_lint_groups(lints: Vec<(&'static str, Vec<lint::LintId>, bool)>)
                         -> Vec<(&'static str, Vec<lint::LintId>)> {
         let mut lints: Vec<_> = lints.into_iter().map(|(x, y, _)| (x, y)).collect();
-        lints.sort_by(|&(x, _): &(&'static str, Vec<lint::LintId>),
+        lints.sort_by_key(|ref l| l.0);
-                       &(y, _): &(&'static str, Vec<lint::LintId>)| {
-            x.cmp(y)
-        });
         lints
     }
 

src/librustc_driver/profile/trace.rs

@@ -202,14 +202,13 @@ fn compute_counts_rec(counts: &mut HashMap<String,QueryMetric>, traces: &Vec<Rec
 
 pub fn write_counts(count_file: &mut File, counts: &mut HashMap<String,QueryMetric>) {
     use rustc::util::common::duration_to_secs_str;
-    use std::cmp::Ordering;
+    use std::cmp::Reverse;
 
     let mut data = vec![];
     for (ref cons, ref qm) in counts.iter() {
         data.push((cons.clone(), qm.count.clone(), qm.dur_total.clone(), qm.dur_self.clone()));
     };
-    data.sort_by(|&(_,_,_,self1),&(_,_,_,self2)|
+    data.sort_by_key(|&k| Reverse(k.3));
-                 if self1 > self2 { Ordering::Less } else { Ordering::Greater } );
     for (cons, count, dur_total, dur_self) in data {
         write!(count_file, "{}, {}, {}, {}\n",
                cons, count,

src/librustc_errors/emitter.rs

@@ -22,7 +22,7 @@ use std::borrow::Cow;
 use std::io::prelude::*;
 use std::io;
 use std::collections::HashMap;
-use std::cmp::min;
+use std::cmp::{min, Reverse};
 use termcolor::{StandardStream, ColorChoice, ColorSpec, BufferWriter};
 use termcolor::{WriteColor, Color, Buffer};
 use unicode_width;
@@ -265,9 +265,7 @@ impl EmitterWriter {
         }
 
         // Find overlapping multiline annotations, put them at different depths
-        multiline_annotations.sort_by(|a, b| {
+        multiline_annotations.sort_by_key(|&(_, ref ml)| (ml.line_start, ml.line_end));
-            (a.1.line_start, a.1.line_end).cmp(&(b.1.line_start, b.1.line_end))
-        });
         for item in multiline_annotations.clone() {
             let ann = item.1;
             for item in multiline_annotations.iter_mut() {
@@ -403,7 +401,7 @@ impl EmitterWriter {
         // otherwise the lines would end up needing to go over a message.
 
         let mut annotations = line.annotations.clone();
-        annotations.sort_by(|a,b| b.start_col.cmp(&a.start_col));
+        annotations.sort_by_key(|a| Reverse(a.start_col));
 
         // First, figure out where each label will be positioned.
         //

src/librustc_metadata/creader.rs

@@ -188,13 +188,12 @@ impl<'a> CrateLoader<'a> {
     fn register_crate(&mut self,
                       root: &Option<CratePaths>,
                       ident: Symbol,
-                      name: Symbol,
                       span: Span,
                       lib: Library,
                       dep_kind: DepKind)
                       -> (CrateNum, Lrc<cstore::CrateMetadata>) {
-        info!("register crate `extern crate {} as {}`", name, ident);
         let crate_root = lib.metadata.get_root();
+        info!("register crate `extern crate {} as {}`", crate_root.name, ident);
         self.verify_no_symbol_conflicts(span, &crate_root);
 
         // Claim this crate number and cache it
@@ -233,7 +232,7 @@ impl<'a> CrateLoader<'a> {
             .collect();
 
         let cmeta = cstore::CrateMetadata {
-            name,
+            name: crate_root.name,
             extern_crate: Lock::new(None),
             def_path_table: Lrc::new(def_path_table),
             trait_impls,
@@ -328,7 +327,7 @@ impl<'a> CrateLoader<'a> {
                 (cnum, data)
             }
             LoadResult::Loaded(library) => {
-                self.register_crate(root, ident, name, span, library, dep_kind)
+                self.register_crate(root, ident, span, library, dep_kind)
             }
         }
     }

src/librustc_mir/borrow_check/error_reporting.rs

@@ -14,7 +14,7 @@ use rustc::mir::{BindingForm, BorrowKind, ClearCrossCrate, Field, Local};
 use rustc::mir::{LocalDecl, LocalKind, Location, Operand, Place};
 use rustc::mir::{ProjectionElem, Rvalue, Statement, StatementKind};
 use rustc::mir::VarBindingForm;
-use rustc::ty::{self, RegionKind};
+use rustc::ty;
 use rustc_data_structures::indexed_vec::Idx;
 use rustc_data_structures::sync::Lrc;
 use syntax_pos::Span;
@@ -427,34 +427,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         self.access_place_error_reported
             .insert((root_place.clone(), borrow_span));
 
-        match (borrow.region, &self.describe_place(&borrow.borrowed_place)) {
+        match &self.describe_place(&borrow.borrowed_place) {
-            (RegionKind::ReScope(_), Some(name)) => {
+            Some(name) => {
-                self.report_scoped_local_value_does_not_live_long_enough(
+                self.report_local_value_does_not_live_long_enough(
-                    context,
-                    name,
-                    &scope_tree,
-                    &borrow,
-                    drop_span,
-                    borrow_span,
-                    proper_span,
-                );
-            }
-            (RegionKind::ReScope(_), None) => {
-                self.report_scoped_temporary_value_does_not_live_long_enough(
-                    context,
-                    &scope_tree,
-                    &borrow,
-                    drop_span,
-                    borrow_span,
-                    proper_span,
-                );
-            }
-            (RegionKind::ReEarlyBound(_), Some(name))
-            | (RegionKind::ReFree(_), Some(name))
-            | (RegionKind::ReStatic, Some(name))
-            | (RegionKind::ReEmpty, Some(name))
-            | (RegionKind::ReVar(_), Some(name)) => {
-                self.report_unscoped_local_value_does_not_live_long_enough(
                     context,
                     name,
                     &scope_tree,
@@ -465,12 +440,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                     kind.map(|k| (k, place_span.0)),
                 );
             }
-            (RegionKind::ReEarlyBound(_), None)
+            None => {
-            | (RegionKind::ReFree(_), None)
+                self.report_temporary_value_does_not_live_long_enough(
-            | (RegionKind::ReStatic, None)
-            | (RegionKind::ReEmpty, None)
-            | (RegionKind::ReVar(_), None) => {
-                self.report_unscoped_temporary_value_does_not_live_long_enough(
                     context,
                     &scope_tree,
                     &borrow,
@@ -479,65 +450,10 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                     proper_span,
                 );
             }
-            (RegionKind::ReLateBound(_, _), _)
-            | (RegionKind::ReSkolemized(_, _), _)
-            | (RegionKind::ReClosureBound(_), _)
-            | (RegionKind::ReCanonical(_), _)
-            | (RegionKind::ReErased, _) => {
-                span_bug!(
-                    drop_span,
-                    "region {:?} does not make sense in this context",
-                    borrow.region
-                );
-            }
         }
     }
 
-    fn report_scoped_local_value_does_not_live_long_enough(
+    fn report_local_value_does_not_live_long_enough(
-        &mut self,
-        context: Context,
-        name: &String,
-        _scope_tree: &Lrc<ScopeTree>,
-        borrow: &BorrowData<'tcx>,
-        drop_span: Span,
-        borrow_span: Span,
-        _proper_span: Span,
-    ) {
-        let tcx = self.tcx;
-        let mut err =
-            tcx.path_does_not_live_long_enough(borrow_span, &format!("`{}`", name), Origin::Mir);
-        err.span_label(borrow_span, "borrowed value does not live long enough");
-        err.span_label(
-            drop_span,
-            format!("`{}` dropped here while still borrowed", name),
-        );
-        self.explain_why_borrow_contains_point(context, borrow, None, &mut err);
-        err.buffer(&mut self.errors_buffer);
-    }
-
-    fn report_scoped_temporary_value_does_not_live_long_enough(
-        &mut self,
-        context: Context,
-        _scope_tree: &Lrc<ScopeTree>,
-        borrow: &BorrowData<'tcx>,
-        drop_span: Span,
-        _borrow_span: Span,
-        proper_span: Span,
-    ) {
-        let tcx = self.tcx;
-        let mut err =
-            tcx.path_does_not_live_long_enough(proper_span, "borrowed value", Origin::Mir);
-        err.span_label(proper_span, "temporary value does not live long enough");
-        err.span_label(
-            drop_span,
-            "temporary value dropped here while still borrowed",
-        );
-        err.note("consider using a `let` binding to increase its lifetime");
-        self.explain_why_borrow_contains_point(context, borrow, None, &mut err);
-        err.buffer(&mut self.errors_buffer);
-    }
-
-    fn report_unscoped_local_value_does_not_live_long_enough(
         &mut self,
         context: Context,
         name: &String,
@@ -549,7 +465,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         kind_place: Option<(WriteKind, &Place<'tcx>)>,
     ) {
         debug!(
-            "report_unscoped_local_value_does_not_live_long_enough(\
+            "report_local_value_does_not_live_long_enough(\
              {:?}, {:?}, {:?}, {:?}, {:?}, {:?}\
              )",
             context, name, scope_tree, borrow, drop_span, borrow_span
@@ -559,13 +475,16 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         let mut err =
             tcx.path_does_not_live_long_enough(borrow_span, &format!("`{}`", name), Origin::Mir);
         err.span_label(borrow_span, "borrowed value does not live long enough");
-        err.span_label(drop_span, "borrowed value only lives until here");
+        err.span_label(
+            drop_span,
+            format!("`{}` dropped here while still borrowed", name),
+        );
 
         self.explain_why_borrow_contains_point(context, borrow, kind_place, &mut err);
         err.buffer(&mut self.errors_buffer);
     }
 
-    fn report_unscoped_temporary_value_does_not_live_long_enough(
+    fn report_temporary_value_does_not_live_long_enough(
         &mut self,
         context: Context,
         scope_tree: &Lrc<ScopeTree>,
@@ -575,7 +494,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         proper_span: Span,
     ) {
         debug!(
-            "report_unscoped_temporary_value_does_not_live_long_enough(\
+            "report_temporary_value_does_not_live_long_enough(\
              {:?}, {:?}, {:?}, {:?}, {:?}\
              )",
             context, scope_tree, borrow, drop_span, proper_span

src/librustc_mir/monomorphize/mod.rs

@@ -29,9 +29,7 @@ pub fn assert_symbols_are_distinct<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, mon
         (mono_item, mono_item.symbol_name(tcx))
     }).collect();
 
-    (&mut symbols[..]).sort_by(|&(_, ref sym1), &(_, ref sym2)|{
+    (&mut symbols[..]).sort_by_key(|&sym| sym.1);
-        sym1.cmp(sym2)
-    });
 
     for pair in (&symbols[..]).windows(2) {
         let sym1 = &pair[0].1;

src/librustc_mir/transform/const_prop.rs

@@ -144,18 +144,100 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
         };
         let r = match f(self) {
             Ok(val) => Some(val),
-            Err(err) => {
+            Err(error) => {
-                match err.kind {
+                let (stacktrace, span) = self.ecx.generate_stacktrace(None);
+                let diagnostic = ConstEvalErr { span, error, stacktrace };
+                use rustc::mir::interpret::EvalErrorKind::*;
+                match diagnostic.error.kind {
                     // don't report these, they make no sense in a const prop context
-                    EvalErrorKind::MachineError(_) => {},
+                    | MachineError(_)
-                    _ => {
+                    // at runtime these transformations might make sense
-                        let (frames, span) = self.ecx.generate_stacktrace(None);
+                    // FIXME: figure out the rules and start linting
-                        let err = ConstEvalErr {
+                    | FunctionPointerTyMismatch(..)
-                            span,
+                    // fine at runtime, might be a register address or sth
-                            error: err,
+                    | ReadBytesAsPointer
-                            stacktrace: frames,
+                    // fine at runtime
-                        };
+                    | ReadForeignStatic
-                        err.report_as_lint(
+                    | Unimplemented(_)
+                    // don't report const evaluator limits
+                    | StackFrameLimitReached
+                    | NoMirFor(..)
+                    | InlineAsm
+                    => {},
+
+                    | InvalidMemoryAccess
+                    | DanglingPointerDeref
+                    | DoubleFree
+                    | InvalidFunctionPointer
+                    | InvalidBool
+                    | InvalidDiscriminant
+                    | PointerOutOfBounds { .. }
+                    | InvalidNullPointerUsage
+                    | MemoryLockViolation { .. }
+                    | MemoryAcquireConflict { .. }
+                    | ValidationFailure(..)
+                    | InvalidMemoryLockRelease { .. }
+                    | DeallocatedLockedMemory { .. }
+                    | InvalidPointerMath
+                    | ReadUndefBytes
+                    | DeadLocal
+                    | InvalidBoolOp(_)
+                    | DerefFunctionPointer
+                    | ExecuteMemory
+                    | Intrinsic(..)
+                    | InvalidChar(..)
+                    | AbiViolation(_)
+                    | AlignmentCheckFailed{..}
+                    | CalledClosureAsFunction
+                    | VtableForArgumentlessMethod
+                    | ModifiedConstantMemory
+                    | AssumptionNotHeld
+                    // FIXME: should probably be removed and turned into a bug! call
+                    | TypeNotPrimitive(_)
+                    | ReallocatedWrongMemoryKind(_, _)
+                    | DeallocatedWrongMemoryKind(_, _)
+                    | ReallocateNonBasePtr
+                    | DeallocateNonBasePtr
+                    | IncorrectAllocationInformation(..)
+                    | UnterminatedCString(_)
+                    | HeapAllocZeroBytes
+                    | HeapAllocNonPowerOfTwoAlignment(_)
+                    | Unreachable
+                    | ReadFromReturnPointer
+                    | GeneratorResumedAfterReturn
+                    | GeneratorResumedAfterPanic
+                    | ReferencedConstant(_)
+                    | InfiniteLoop
+                    => {
+                        // FIXME: report UB here
+                    },
+
+                    | OutOfTls
+                    | TlsOutOfBounds
+                    | PathNotFound(_)
+                    => bug!("these should not be in rustc, but in miri's machine errors"),
+
+                    | Layout(_)
+                    | UnimplementedTraitSelection
+                    | TypeckError
+                    | TooGeneric
+                    | CheckMatchError
+                    // these are just noise
+                    => {},
+
+                    // non deterministic
+                    | ReadPointerAsBytes
+                    // FIXME: implement
+                    => {},
+
+                    | Panic
+                    | BoundsCheck{..}
+                    | Overflow(_)
+                    | OverflowNeg
+                    | DivisionByZero
+                    | RemainderByZero
+                    => {
+                        diagnostic.report_as_lint(
                             self.ecx.tcx,
                             "this expression will panic at runtime",
                             lint_root,

src/librustc_mir/util/patch.rs

@@ -156,7 +156,7 @@ impl<'tcx> MirPatch<'tcx> {
         }
 
         let mut new_statements = self.new_statements;
-        new_statements.sort_by(|u,v| u.0.cmp(&v.0));
+        new_statements.sort_by_key(|s| s.0);
 
         let mut delta = 0;
         let mut last_bb = START_BLOCK;

src/librustc_target/abi/call/sparc64.rs

@@ -57,16 +57,7 @@ fn classify_ret_ty<'a, Ty, C>(cx: C, ret: &mut ArgType<'a, Ty>)
     let size = ret.layout.size;
     let bits = size.bits();
     if bits <= 256 {
-        let unit = if bits <= 8 {
+        let unit = Reg::i64();
-            Reg::i8()
-        } else if bits <= 16 {
-            Reg::i16()
-        } else if bits <= 32 {
-            Reg::i32()
-        } else {
-            Reg::i64()
-        };
-
         ret.cast_to(Uniform {
             unit,
             total: size

src/librustc_typeck/collect.rs

@@ -1746,7 +1746,7 @@ pub fn compute_bounds<'gcx: 'tcx, 'tcx>(astconv: &dyn AstConv<'gcx, 'tcx>,
         astconv.ast_region_to_region(r, None)
     }).collect();
 
-    trait_bounds.sort_by(|a,b| a.def_id().cmp(&b.def_id()));
+    trait_bounds.sort_by_key(|t| t.def_id());
 
     let implicitly_sized = if let SizedByDefault::Yes = sized_by_default {
         !is_unsized(astconv, ast_bounds, span)

src/libstd/io/buffered.rs

@@ -61,7 +61,8 @@ pub struct BufReader<R> {
 }
 
 impl<R: Read> BufReader<R> {
-    /// Creates a new `BufReader` with a default buffer capacity.
+    /// Creates a new `BufReader` with a default buffer capacity. The default is currently 8 KB,
+    /// but may change in the future.
     ///
     /// # Examples
     ///
@@ -454,7 +455,8 @@ pub struct BufWriter<W: Write> {
 pub struct IntoInnerError<W>(W, Error);
 
 impl<W: Write> BufWriter<W> {
-    /// Creates a new `BufWriter` with a default buffer capacity.
+    /// Creates a new `BufWriter` with a default buffer capacity. The default is currently 8 KB,
+    /// but may change in the future.
     ///
     /// # Examples
     ///

src/libsyntax_ext/format.rs

@@ -14,18 +14,18 @@ use self::Position::*;
 use fmt_macros as parse;
 
 use syntax::ast;
-use syntax::ext::base::*;
 use syntax::ext::base;
+use syntax::ext::base::*;
 use syntax::ext::build::AstBuilder;
 use syntax::feature_gate;
 use syntax::parse::token;
 use syntax::ptr::P;
 use syntax::symbol::Symbol;
-use syntax_pos::{Span, DUMMY_SP};
 use syntax::tokenstream;
+use syntax_pos::{MultiSpan, Span, DUMMY_SP};
 
-use std::collections::{HashMap, HashSet};
 use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
 
 #[derive(PartialEq)]
 enum ArgumentType {
@@ -111,8 +111,14 @@ struct Context<'a, 'b: 'a> {
     /// still existed in this phase of processing.
     /// Used only for `all_pieces_simple` tracking in `build_piece`.
     curarg: usize,
-    /// Keep track of invalid references to positional arguments
+    /// Current piece being evaluated, used for error reporting.
-    invalid_refs: Vec<usize>,
+    curpiece: usize,
+    /// Keep track of invalid references to positional arguments.
+    invalid_refs: Vec<(usize, usize)>,
+    /// Spans of all the formatting arguments, in order.
+    arg_spans: Vec<Span>,
+    /// Wether this formatting string is a literal or it comes from a macro.
+    is_literal: bool,
 }
 
 /// Parses the arguments from the given list of tokens, returning None
@@ -155,15 +161,20 @@ fn parse_args(ecx: &mut ExtCtxt,
                     i
                 }
                 _ if named => {
-                    ecx.span_err(p.span,
+                    ecx.span_err(
-                                 "expected ident, positional arguments \
+                        p.span,
-                                 cannot follow named arguments");
+                        "expected ident, positional arguments cannot follow named arguments",
+                    );
                     return None;
                 }
                 _ => {
-                    ecx.span_err(p.span,
+                    ecx.span_err(
-                                 &format!("expected ident for named argument, found `{}`",
+                        p.span,
-                                          p.this_token_to_string()));
+                        &format!(
+                            "expected ident for named argument, found `{}`",
+                            p.this_token_to_string()
+                        ),
+                    );
                     return None;
                 }
             };
@@ -235,6 +246,7 @@ impl<'a, 'b> Context<'a, 'b> {
 
                 let ty = Placeholder(arg.format.ty.to_string());
                 self.verify_arg_type(pos, ty);
+                self.curpiece += 1;
             }
         }
     }
@@ -266,26 +278,56 @@ impl<'a, 'b> Context<'a, 'b> {
     /// format string.
     fn report_invalid_references(&self, numbered_position_args: bool) {
         let mut e;
-        let mut refs: Vec<String> = self.invalid_refs
+        let sp = if self.is_literal {
+            MultiSpan::from_spans(self.arg_spans.clone())
+        } else {
+            MultiSpan::from_span(self.fmtsp)
+        };
+        let mut refs: Vec<_> = self
+            .invalid_refs
             .iter()
-                                        .map(|r| r.to_string())
+            .map(|(r, pos)| (r.to_string(), self.arg_spans.get(*pos)))
             .collect();
 
         if self.names.is_empty() && !numbered_position_args {
-            e = self.ecx.mut_span_err(self.fmtsp,
+            e = self.ecx.mut_span_err(
-                &format!("{} positional argument{} in format string, but {}",
+                sp,
+                &format!(
+                    "{} positional argument{} in format string, but {}",
                          self.pieces.len(),
                          if self.pieces.len() > 1 { "s" } else { "" },
-                         self.describe_num_args()));
+                    self.describe_num_args()
+                ),
+            );
         } else {
-            let arg_list = match refs.len() {
+            let (arg_list, mut sp) = match refs.len() {
-                1 => format!("argument {}", refs.pop().unwrap()),
+                1 => {
-                _ => format!("arguments {head} and {tail}",
+                    let (reg, pos) = refs.pop().unwrap();
-                             tail=refs.pop().unwrap(),
+                    (
-                             head=refs.join(", "))
+                        format!("argument {}", reg),
+                        MultiSpan::from_span(*pos.unwrap_or(&self.fmtsp)),
+                    )
+                }
+                _ => {
+                    let pos =
+                        MultiSpan::from_spans(refs.iter().map(|(_, p)| *p.unwrap()).collect());
+                    let mut refs: Vec<String> = refs.iter().map(|(s, _)| s.to_owned()).collect();
+                    let reg = refs.pop().unwrap();
+                    (
+                        format!(
+                            "arguments {head} and {tail}",
+                            tail = reg,
+                            head = refs.join(", ")
+                        ),
+                        pos,
+                    )
+                }
             };
+            if !self.is_literal {
+                sp = MultiSpan::from_span(self.fmtsp);
+            }
 
-            e = self.ecx.mut_span_err(self.fmtsp,
+            e = self.ecx.mut_span_err(sp,
                 &format!("invalid reference to positional {} ({})",
                          arg_list,
                          self.describe_num_args()));
@@ -301,7 +343,7 @@ impl<'a, 'b> Context<'a, 'b> {
         match arg {
             Exact(arg) => {
                 if self.args.len() <= arg {
-                    self.invalid_refs.push(arg);
+                    self.invalid_refs.push((arg, self.curpiece));
                     return;
                 }
                 match ty {
@@ -337,7 +379,13 @@ impl<'a, 'b> Context<'a, 'b> {
                     Some(e) => *e,
                     None => {
                         let msg = format!("there is no argument named `{}`", name);
-                        self.ecx.span_err(self.fmtsp, &msg[..]);
+                        let sp = if self.is_literal {
+                            *self.arg_spans.get(self.curpiece).unwrap_or(&self.fmtsp)
+                        } else {
+                            self.fmtsp
+                        };
+                        let mut err = self.ecx.struct_span_err(sp, &msg[..]);
+                        err.emit();
                         return;
                     }
                 };
@@ -505,33 +553,27 @@ impl<'a, 'b> Context<'a, 'b> {
                 let prec = self.build_count(arg.format.precision);
                 let width = self.build_count(arg.format.width);
                 let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "FormatSpec"));
-                let fmt =
+                let fmt = self.ecx.expr_struct(
-                    self.ecx.expr_struct(sp,
+                    sp,
                                          path,
-                                         vec![self.ecx
+                    vec![
-                                                  .field_imm(sp, self.ecx.ident_of("fill"), fill),
+                        self.ecx.field_imm(sp, self.ecx.ident_of("fill"), fill),
-                                              self.ecx.field_imm(sp,
+                        self.ecx.field_imm(sp, self.ecx.ident_of("align"), align),
-                                                                 self.ecx.ident_of("align"),
+                        self.ecx.field_imm(sp, self.ecx.ident_of("flags"), flags),
-                                                                 align),
+                        self.ecx.field_imm(sp, self.ecx.ident_of("precision"), prec),
-                                              self.ecx.field_imm(sp,
+                        self.ecx.field_imm(sp, self.ecx.ident_of("width"), width),
-                                                                 self.ecx.ident_of("flags"),
+                    ],
-                                                                 flags),
+                );
-                                              self.ecx.field_imm(sp,
-                                                                 self.ecx.ident_of("precision"),
-                                                                 prec),
-                                              self.ecx.field_imm(sp,
-                                                                 self.ecx.ident_of("width"),
-                                                                 width)]);
 
                 let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "Argument"));
-                Some(self.ecx.expr_struct(sp,
+                Some(self.ecx.expr_struct(
+                    sp,
                                           path,
-                                          vec![self.ecx.field_imm(sp,
+                    vec![
-                                                                  self.ecx.ident_of("position"),
+                        self.ecx.field_imm(sp, self.ecx.ident_of("position"), pos),
-                                                                  pos),
+                        self.ecx.field_imm(sp, self.ecx.ident_of("format"), fmt),
-                                               self.ecx.field_imm(sp,
+                    ],
-                                                                  self.ecx.ident_of("format"),
+                ))
-                                                                  fmt)]))
             }
         }
     }
@@ -544,9 +586,9 @@ impl<'a, 'b> Context<'a, 'b> {
         let mut pats = Vec::new();
         let mut heads = Vec::new();
 
-        let names_pos: Vec<_> = (0..self.args.len()).map(|i| {
+        let names_pos: Vec<_> = (0..self.args.len())
-            self.ecx.ident_of(&format!("arg{}", i)).gensym()
+            .map(|i| self.ecx.ident_of(&format!("arg{}", i)).gensym())
-        }).collect();
+            .collect();
 
         // First, build up the static array which will become our precompiled
         // format "string"
@@ -690,10 +732,11 @@ pub fn expand_format_args<'cx>(ecx: &'cx mut ExtCtxt,
     }
 }
 
-pub fn expand_format_args_nl<'cx>(ecx: &'cx mut ExtCtxt,
+pub fn expand_format_args_nl<'cx>(
+    ecx: &'cx mut ExtCtxt,
     mut sp: Span,
-                                  tts: &[tokenstream::TokenTree])
+    tts: &[tokenstream::TokenTree],
-                                  -> Box<dyn base::MacResult + 'cx> {
+) -> Box<dyn base::MacResult + 'cx> {
     //if !ecx.ecfg.enable_allow_internal_unstable() {
 
     // For some reason, the only one that actually works for `println` is the first check
@@ -744,7 +787,6 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
             let sugg_fmt = match args.len() {
                 0 => "{}".to_string(),
                 _ => format!("{}{{}}", "{} ".repeat(args.len())),
-
             };
             err.span_suggestion(
                 fmt_sp.shrink_to_lo(),
@@ -753,7 +795,11 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
             );
             err.emit();
             return DummyResult::raw_expr(sp);
-        },
+        }
+    };
+    let is_literal = match ecx.codemap().span_to_snippet(fmt_sp) {
+        Ok(ref s) if s.starts_with("\"") || s.starts_with("r#") => true,
+        _ => false,
     };
 
     let mut cx = Context {
@@ -763,6 +809,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
         arg_unique_types,
         names,
         curarg: 0,
+        curpiece: 0,
         arg_index_map: Vec::new(),
         count_args: Vec::new(),
         count_positions: HashMap::new(),
@@ -775,6 +822,8 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
         macsp,
         fmtsp: fmt.span,
         invalid_refs: Vec::new(),
+        arg_spans: Vec::new(),
+        is_literal,
     };
 
     let fmt_str = &*fmt.node.0.as_str();
@@ -783,12 +832,22 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
         ast::StrStyle::Raw(raw) => Some(raw as usize),
     };
     let mut parser = parse::Parser::new(fmt_str, str_style);
+    let mut unverified_pieces = vec![];
     let mut pieces = vec![];
 
-    while let Some(mut piece) = parser.next() {
+    while let Some(piece) = parser.next() {
         if !parser.errors.is_empty() {
             break;
         }
+        unverified_pieces.push(piece);
+    }
+
+    cx.arg_spans = parser.arg_places.iter()
+        .map(|&(start, end)| fmt.span.from_inner_byte_pos(start, end))
+        .collect();
+
+    // This needs to happen *after* the Parser has consumed all pieces to create all the spans
+    for mut piece in unverified_pieces {
         cx.verify_piece(&piece);
         cx.resolve_name_inplace(&mut piece);
         pieces.push(piece);
@@ -856,24 +915,27 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
             errs.push((cx.args[i].span, msg));
         }
     }
-    if errs.len() > 0 {
+    let errs_len = errs.len();
-        let args_used = cx.arg_types.len() - errs.len();
+    if errs_len > 0 {
-        let args_unused = errs.len();
+        let args_used = cx.arg_types.len() - errs_len;
+        let args_unused = errs_len;
 
         let mut diag = {
-            if errs.len() == 1 {
+            if errs_len == 1 {
                 let (sp, msg) = errs.into_iter().next().unwrap();
                 cx.ecx.struct_span_err(sp, msg)
             } else {
                 let mut diag = cx.ecx.struct_span_err(
                     errs.iter().map(|&(sp, _)| sp).collect::<Vec<Span>>(),
-                    "multiple unused formatting arguments"
+                    "multiple unused formatting arguments",
                 );
-                diag.span_label(cx.fmtsp, "multiple missing formatting arguments");
+                diag.span_label(cx.fmtsp, "multiple missing formatting specifiers");
                 diag
             }
         };
 
+        // Used to ensure we only report translations for *one* kind of foreign format.
+        let mut found_foreign = false;
         // Decide if we want to look for foreign formatting directives.
         if args_used < args_unused {
             use super::format_foreign as foreign;
@@ -882,13 +944,11 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
             // with `%d should be written as {}` over and over again.
             let mut explained = HashSet::new();
 
-            // Used to ensure we only report translations for *one* kind of foreign format.
-            let mut found_foreign = false;
-
             macro_rules! check_foreign {
                 ($kind:ident) => {{
                     let mut show_doc_note = false;
 
+                    let mut suggestions = vec![];
                     for sub in foreign::$kind::iter_subs(fmt_str) {
                         let trn = match sub.translate() {
                             Some(trn) => trn,
@@ -897,6 +957,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
                             None => continue,
                         };
 
+                        let pos = sub.position();
                         let sub = String::from(sub.as_str());
                         if explained.contains(&sub) {
                             continue;
@@ -908,8 +969,15 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
                             show_doc_note = true;
                         }
 
+                        if let Some((start, end)) = pos {
+                            // account for `"` and account for raw strings `r#`
+                            let padding = str_style.map(|i| i + 2).unwrap_or(1);
+                            let sp = fmt_sp.from_inner_byte_pos(start + padding, end + padding);
+                            suggestions.push((sp, trn));
+                        } else {
                             diag.help(&format!("`{}` should be written as `{}`", sub, trn));
                         }
+                    }
 
                     if show_doc_note {
                         diag.note(concat!(
@@ -917,6 +985,12 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
                             " formatting not supported; see the documentation for `std::fmt`",
                         ));
                     }
+                    if suggestions.len() > 0 {
+                        diag.multipart_suggestion(
+                            "format specifiers use curly braces",
+                            suggestions,
+                        );
+                    }
                 }};
             }
 
@@ -925,6 +999,9 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt,
                 check_foreign!(shell);
             }
         }
+        if !found_foreign && errs_len == 1 {
+            diag.span_label(cx.fmtsp, "formatting specifier missing");
+        }
 
         diag.emit();
     }

src/libsyntax_ext/format_foreign.rs

@@ -14,7 +14,7 @@ pub mod printf {
     /// Represents a single `printf`-style substitution.
     #[derive(Clone, PartialEq, Debug)]
     pub enum Substitution<'a> {
-        /// A formatted output substitution.
+        /// A formatted output substitution with its internal byte offset.
         Format(Format<'a>),
         /// A literal `%%` escape.
         Escape,
@@ -28,6 +28,23 @@ pub mod printf {
             }
         }
 
+        pub fn position(&self) -> Option<(usize, usize)> {
+            match *self {
+                Substitution::Format(ref fmt) => Some(fmt.position),
+                _ => None,
+            }
+        }
+
+        pub fn set_position(&mut self, start: usize, end: usize) {
+            match self {
+                Substitution::Format(ref mut fmt) => {
+                    fmt.position = (start, end);
+                }
+                _ => {}
+            }
+        }
+
+
         /// Translate this substitution into an equivalent Rust formatting directive.
         ///
         /// This ignores cases where the substitution does not have an exact equivalent, or where
@@ -57,6 +74,8 @@ pub mod printf {
         pub length: Option<&'a str>,
         /// Type of parameter being converted.
         pub type_: &'a str,
+        /// Byte offset for the start and end of this formatting directive.
+        pub position: (usize, usize),
     }
 
     impl<'a> Format<'a> {
@@ -257,19 +276,28 @@ pub mod printf {
     pub fn iter_subs(s: &str) -> Substitutions {
         Substitutions {
             s,
+            pos: 0,
         }
     }
 
     /// Iterator over substitutions in a string.
     pub struct Substitutions<'a> {
         s: &'a str,
+        pos: usize,
     }
 
     impl<'a> Iterator for Substitutions<'a> {
         type Item = Substitution<'a>;
         fn next(&mut self) -> Option<Self::Item> {
-            let (sub, tail) = parse_next_substitution(self.s)?;
+            let (mut sub, tail) = parse_next_substitution(self.s)?;
             self.s = tail;
+            match sub {
+                Substitution::Format(_) => if let Some((start, end)) = sub.position() {
+                    sub.set_position(start + self.pos, end + self.pos);
+                    self.pos += end;
+                }
+                Substitution::Escape => self.pos += 2,
+            }
             Some(sub)
         }
 
@@ -301,7 +329,7 @@ pub mod printf {
                 _ => {/* fall-through */},
             }
 
-            Cur::new_at_start(&s[start..])
+            Cur::new_at(&s[..], start)
         };
 
         // This is meant to be a translation of the following regex:
@@ -355,6 +383,7 @@ pub mod printf {
                     precision: None,
                     length: None,
                     type_: at.slice_between(next).unwrap(),
+                    position: (start.at, next.at),
                 }),
                 next.slice_after()
             ));
@@ -541,6 +570,7 @@ pub mod printf {
         drop(next);
 
         end = at;
+        let position = (start.at, end.at);
 
         let f = Format {
             span: start.slice_between(end).unwrap(),
@@ -550,6 +580,7 @@ pub mod printf {
             precision,
             length,
             type_,
+            position,
         };
         Some((Substitution::Format(f), end.slice_after()))
     }
@@ -616,6 +647,7 @@ pub mod printf {
                 ($in_:expr, {
                     $param:expr, $flags:expr,
                     $width:expr, $prec:expr, $len:expr, $type_:expr,
+                    $pos:expr,
                 }) => {
                     assert_eq!(
                         pns(concat!($in_, "!")),
@@ -628,6 +660,7 @@ pub mod printf {
                                 precision: $prec,
                                 length: $len,
                                 type_: $type_,
+                                position: $pos,
                             }),
                             "!"
                         ))
@@ -636,53 +669,53 @@ pub mod printf {
             }
 
             assert_pns_eq_sub!("%!",
-                { None, "", None, None, None, "!", });
+                { None, "", None, None, None, "!", (0, 2), });
             assert_pns_eq_sub!("%c",
-                { None, "", None, None, None, "c", });
+                { None, "", None, None, None, "c", (0, 2), });
             assert_pns_eq_sub!("%s",
-                { None, "", None, None, None, "s", });
+                { None, "", None, None, None, "s", (0, 2), });
             assert_pns_eq_sub!("%06d",
-                { None, "0", Some(N::Num(6)), None, None, "d", });
+                { None, "0", Some(N::Num(6)), None, None, "d", (0, 4), });
             assert_pns_eq_sub!("%4.2f",
-                { None, "", Some(N::Num(4)), Some(N::Num(2)), None, "f", });
+                { None, "", Some(N::Num(4)), Some(N::Num(2)), None, "f", (0, 5), });
             assert_pns_eq_sub!("%#x",
-                { None, "#", None, None, None, "x", });
+                { None, "#", None, None, None, "x", (0, 3), });
             assert_pns_eq_sub!("%-10s",
-                { None, "-", Some(N::Num(10)), None, None, "s", });
+                { None, "-", Some(N::Num(10)), None, None, "s", (0, 5), });
             assert_pns_eq_sub!("%*s",
-                { None, "", Some(N::Next), None, None, "s", });
+                { None, "", Some(N::Next), None, None, "s", (0, 3), });
             assert_pns_eq_sub!("%-10.*s",
-                { None, "-", Some(N::Num(10)), Some(N::Next), None, "s", });
+                { None, "-", Some(N::Num(10)), Some(N::Next), None, "s", (0, 7), });
             assert_pns_eq_sub!("%-*.*s",
-                { None, "-", Some(N::Next), Some(N::Next), None, "s", });
+                { None, "-", Some(N::Next), Some(N::Next), None, "s", (0, 6), });
             assert_pns_eq_sub!("%.6i",
-                { None, "", None, Some(N::Num(6)), None, "i", });
+                { None, "", None, Some(N::Num(6)), None, "i", (0, 4), });
             assert_pns_eq_sub!("%+i",
-                { None, "+", None, None, None, "i", });
+                { None, "+", None, None, None, "i", (0, 3), });
             assert_pns_eq_sub!("%08X",
-                { None, "0", Some(N::Num(8)), None, None, "X", });
+                { None, "0", Some(N::Num(8)), None, None, "X", (0, 4), });
             assert_pns_eq_sub!("%lu",
-                { None, "", None, None, Some("l"), "u", });
+                { None, "", None, None, Some("l"), "u", (0, 3), });
             assert_pns_eq_sub!("%Iu",
-                { None, "", None, None, Some("I"), "u", });
+                { None, "", None, None, Some("I"), "u", (0, 3), });
             assert_pns_eq_sub!("%I32u",
-                { None, "", None, None, Some("I32"), "u", });
+                { None, "", None, None, Some("I32"), "u", (0, 5), });
             assert_pns_eq_sub!("%I64u",
-                { None, "", None, None, Some("I64"), "u", });
+                { None, "", None, None, Some("I64"), "u", (0, 5), });
             assert_pns_eq_sub!("%'d",
-                { None, "'", None, None, None, "d", });
+                { None, "'", None, None, None, "d", (0, 3), });
             assert_pns_eq_sub!("%10s",
-                { None, "", Some(N::Num(10)), None, None, "s", });
+                { None, "", Some(N::Num(10)), None, None, "s", (0, 4), });
             assert_pns_eq_sub!("%-10.10s",
-                { None, "-", Some(N::Num(10)), Some(N::Num(10)), None, "s", });
+                { None, "-", Some(N::Num(10)), Some(N::Num(10)), None, "s", (0, 8), });
             assert_pns_eq_sub!("%1$d",
-                { Some(1), "", None, None, None, "d", });
+                { Some(1), "", None, None, None, "d", (0, 4), });
             assert_pns_eq_sub!("%2$.*3$d",
-                { Some(2), "", None, Some(N::Arg(3)), None, "d", });
+                { Some(2), "", None, Some(N::Arg(3)), None, "d", (0, 8), });
             assert_pns_eq_sub!("%1$*2$.*3$d",
-                { Some(1), "", Some(N::Arg(2)), Some(N::Arg(3)), None, "d", });
+                { Some(1), "", Some(N::Arg(2)), Some(N::Arg(3)), None, "d", (0, 11), });
             assert_pns_eq_sub!("%-8ld",
-                { None, "-", Some(N::Num(8)), None, Some("l"), "d", });
+                { None, "-", Some(N::Num(8)), None, Some("l"), "d", (0, 5), });
         }
 
         #[test]
@@ -755,6 +788,12 @@ pub mod shell {
             }
         }
 
+        pub fn position(&self) -> Option<(usize, usize)> {
+            match *self {
+                _ => None,
+            }
+        }
+
         pub fn translate(&self) -> Option<String> {
             match *self {
                 Substitution::Ordinal(n) => Some(format!("{{{}}}", n)),
@@ -918,7 +957,7 @@ mod strcursor {
 
     pub struct StrCursor<'a> {
         s: &'a str,
-        at: usize,
+        pub at: usize,
     }
 
     impl<'a> StrCursor<'a> {
@@ -929,6 +968,13 @@ mod strcursor {
             }
         }
 
+        pub fn new_at(s: &'a str, at: usize) -> StrCursor<'a> {
+            StrCursor {
+                s,
+                at,
+            }
+        }
+
         pub fn at_next_cp(mut self) -> Option<StrCursor<'a>> {
             match self.try_seek_right_cp() {
                 true => Some(self),

src/stdsimd

@@ -1 +1 @@
-Subproject commit b9de11ab43090c71ff7ab159a479394df1f968ab
+Subproject commit 05c2f61c384e2097a3a4c648344114fc4ac983be

src/test/codegen/sparc-struct-abi.rs

@@ -0,0 +1,36 @@
+// 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.
+//
+// Checks that we correctly codegen extern "C" functions returning structs.
+// See issue #52638.
+
+// compile-flags: -O --target=sparc64-unknown-linux-gnu --crate-type=rlib
+#![feature(no_core, lang_items)]
+#![no_core]
+
+#[lang="sized"]
+trait Sized { }
+#[lang="freeze"]
+trait Freeze { }
+#[lang="copy"]
+trait Copy { }
+
+#[repr(C)]
+pub struct Bool {
+    b: bool,
+}
+
+// CHECK: define i64 @structbool()
+// CHECK-NEXT: start:
+// CHECK-NEXT: ret i64 72057594037927936
+#[no_mangle]
+pub extern "C" fn structbool() -> Bool {
+    Bool { b: true }
+}

src/test/run-make-fulldeps/extern-flag-rename-transitive/Makefile

@@ -0,0 +1,7 @@
+-include ../tools.mk
+
+all:
+	$(RUSTC) foo.rs
+	$(RUSTC) bar.rs
+	$(RUSTC) baz.rs --extern a=$(TMPDIR)/libfoo.rlib
+

src/test/run-make-fulldeps/extern-flag-rename-transitive/bar.rs

@@ -0,0 +1,13 @@
+// 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.
+
+#![crate_type = "rlib"]
+
+extern crate foo;

src/test/run-make-fulldeps/extern-flag-rename-transitive/baz.rs

@@ -0,0 +1,14 @@
+// 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.
+
+#![crate_type = "rlib"]
+
+extern crate a;
+extern crate bar;

src/test/run-make-fulldeps/extern-flag-rename-transitive/foo.rs

@@ -0,0 +1,11 @@
+// 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.
+
+#![crate_type = "rlib"]

src/test/run-pass/issue-18804/auxiliary/lib.rs

@@ -0,0 +1,20 @@
+// 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.
+
+#![crate_type = "rlib"]
+#![feature(linkage)]
+
+pub fn foo<T>() -> *const() {
+    extern {
+        #[linkage = "extern_weak"]
+        static FOO: *const();
+    }
+    unsafe { FOO }
+}

src/test/run-pass/issue-18804/main.rs

@@ -0,0 +1,23 @@
+// 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.
+
+// Test for issue #18804, #[linkage] does not propagate thorugh generic
+// functions. Failure results in a linker error.
+
+// ignore-asmjs no weak symbol support
+// ignore-emscripten no weak symbol support
+
+// aux-build:lib.rs
+
+extern crate lib;
+
+fn main() {
+    lib::foo::<i32>();
+}

src/test/run-pass/issue-33264.rs

@@ -0,0 +1,39 @@
+// 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.
+
+// only-x86_64
+
+#![allow(dead_code, non_upper_case_globals)]
+#![feature(asm)]
+
+#[repr(C)]
+pub struct D32x4(f32,f32,f32,f32);
+
+impl D32x4 {
+    fn add(&self, vec: Self) -> Self {
+        unsafe {
+            let ret: Self;
+            asm!("
+                 movaps $1, %xmm1
+                 movaps $2, %xmm2
+                 addps %xmm1, %xmm2
+                 movaps $xmm1, $0
+                 "
+                 : "=r"(ret)
+                 : "1"(self), "2"(vec)
+                 : "xmm1", "xmm2"
+                 );
+            ret
+        }
+    }
+}
+
+fn main() { }
+

src/test/run-pass/issue-34784.rs

@@ -0,0 +1,28 @@
+// 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.
+
+const C: *const u8 = &0;
+
+fn foo(x: *const u8) {
+    match x {
+        C => {}
+        _ => {}
+    }
+}
+
+const D: *const [u8; 4] = b"abcd";
+
+fn main() {
+    match D {
+        D => {}
+        _ => {}
+    }
+}
+

src/test/run-pass/issue-44005.rs

@@ -0,0 +1,39 @@
+// 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.
+
+pub trait Foo<'a> {
+    type Bar;
+    fn foo(&'a self) -> Self::Bar;
+}
+
+impl<'a, 'b, T: 'a> Foo<'a> for &'b T {
+    type Bar = &'a T;
+    fn foo(&'a self) -> &'a T {
+        self
+    }
+}
+
+pub fn uncallable<T, F>(x: T, f: F)
+    where T: for<'a> Foo<'a>,
+          F: for<'a> Fn(<T as Foo<'a>>::Bar)
+{
+    f(x.foo());
+}
+
+pub fn catalyst(x: &i32) {
+    broken(x, |_| {})
+}
+
+pub fn broken<F: Fn(&i32)>(x: &i32, f: F) {
+    uncallable(x, |y| f(y));
+}
+
+fn main() { }
+

src/test/ui/borrowck/borrowck-escaping-closure-error-1.nll.stderr

@@ -5,7 +5,7 @@ LL |     spawn(|| books.push(4));
    |           ^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 LL |     //~^ ERROR E0373
 LL | }
-   | - borrowed value only lives until here
+   | - `books` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/borrowck/borrowck-escaping-closure-error-2.nll.stderr

@@ -5,7 +5,7 @@ LL |     Box::new(|| books.push(4))
    |              ^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 LL |     //~^ ERROR E0373
 LL | }
-   | - borrowed value only lives until here
+   | - `books` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 19:8...
   --> $DIR/borrowck-escaping-closure-error-2.rs:19:8

src/test/ui/const-eval/const_prop_errors.rs

@@ -0,0 +1,24 @@
+// 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.
+
+// compile-pass
+
+pub trait Foo {
+    fn foo(self) -> u32;
+}
+
+impl<T> Foo for T {
+    fn foo(self) -> u32 {
+        fn bar<T>() { loop {} }
+        bar::<T> as u32
+    }
+}
+
+fn main() {}

src/test/ui/dropck/dropck-eyepatch-extern-crate.nll.stderr

@@ -7,7 +7,7 @@ LL |     dt = Dt("dt", &c_shortest);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `c_shortest` dropped here while still borrowed
    | borrow later used here, when `dt` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/dropck/dropck-eyepatch-reorder.nll.stderr

@@ -7,7 +7,7 @@ LL |     dt = Dt("dt", &c_shortest);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `c_shortest` dropped here while still borrowed
    | borrow later used here, when `dt` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/dropck/dropck-eyepatch.nll.stderr

@@ -7,7 +7,7 @@ LL |     dt = Dt("dt", &c_shortest);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `c_shortest` dropped here while still borrowed
    | borrow later used here, when `dt` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/error-codes/E0597.nll.stderr

@@ -7,7 +7,7 @@ LL |     //~^ `y` does not live long enough [E0597]
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `y` dropped here while still borrowed
    | borrow later used here, when `x` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/generator/borrowing.nll.stderr

@@ -5,7 +5,7 @@ LL |         unsafe { (|| yield &a).resume() }
    |                  ^^^^^^^^^^^^^ borrowed value does not live long enough
 LL |         //~^ ERROR: `a` does not live long enough
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `a` dropped here while still borrowed
 
 error[E0597]: `a` does not live long enough
   --> $DIR/borrowing.rs:24:9
@@ -16,7 +16,7 @@ LL | |             //~^ ERROR: `a` does not live long enough
 LL | |         }
    | |_________^ borrowed value does not live long enough
 LL |       };
-   |       - borrowed value only lives until here
+   |       - `a` dropped here while still borrowed
 LL |   }
    |   - borrow later used here, when `_b` is dropped
 

src/test/ui/generator/dropck.nll.stderr

@@ -7,7 +7,7 @@ LL |     let ref_ = Box::leak(Box::new(Some(cell.borrow_mut())));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `*cell` dropped here while still borrowed
    | borrow later used here, when `gen` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined
@@ -26,7 +26,7 @@ LL | |     };
 LL |   }
    |   -
    |   |
-   |   borrowed value only lives until here
+   |   `ref_` dropped here while still borrowed
    |   borrow later used here, when `gen` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/generator/ref-escapes-but-not-over-yield.nll.stderr

@@ -5,7 +5,7 @@ LL |         a = &b;
    |             ^^ borrowed value does not live long enough
 LL |         //~^ ERROR `b` does not live long enough
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `b` dropped here while still borrowed
 
 error: aborting due to previous error
 

src/test/ui/ifmt-bad-arg.rs

@@ -64,4 +64,11 @@ fn main() {
     format!("foo }"); //~ ERROR: unmatched `}` found
 
     format!("foo %s baz", "bar"); //~ ERROR: argument never used
+
+    format!(r##"
+
+        {foo}
+
+    "##);
+    //~^^^ ERROR: there is no argument named `foo`
 }

src/test/ui/ifmt-bad-arg.stderr

@@ -0,0 +1,208 @@
+error: 1 positional argument in format string, but no arguments were given
+  --> $DIR/ifmt-bad-arg.rs:16:14
+   |
+LL |     format!("{}");
+   |              ^^
+
+error: invalid reference to positional argument 1 (there is 1 argument)
+  --> $DIR/ifmt-bad-arg.rs:19:14
+   |
+LL |     format!("{1}", 1);
+   |              ^^^
+   |
+   = note: positional arguments are zero-based
+
+error: argument never used
+  --> $DIR/ifmt-bad-arg.rs:19:20
+   |
+LL |     format!("{1}", 1);
+   |             -----  ^
+   |             |
+   |             formatting specifier missing
+
+error: 2 positional arguments in format string, but no arguments were given
+  --> $DIR/ifmt-bad-arg.rs:23:14
+   |
+LL |     format!("{} {}");
+   |              ^^ ^^
+
+error: invalid reference to positional argument 1 (there is 1 argument)
+  --> $DIR/ifmt-bad-arg.rs:26:18
+   |
+LL |     format!("{0} {1}", 1);
+   |                  ^^^
+   |
+   = note: positional arguments are zero-based
+
+error: invalid reference to positional argument 2 (there are 2 arguments)
+  --> $DIR/ifmt-bad-arg.rs:29:22
+   |
+LL |     format!("{0} {1} {2}", 1, 2);
+   |                      ^^^
+   |
+   = note: positional arguments are zero-based
+
+error: invalid reference to positional argument 2 (there are 2 arguments)
+  --> $DIR/ifmt-bad-arg.rs:32:28
+   |
+LL |     format!("{} {value} {} {}", 1, value=2);
+   |                            ^^
+   |
+   = note: positional arguments are zero-based
+
+error: invalid reference to positional arguments 3, 4 and 5 (there are 3 arguments)
+  --> $DIR/ifmt-bad-arg.rs:34:38
+   |
+LL |     format!("{name} {value} {} {} {} {} {} {}", 0, name=1, value=2);
+   |                                      ^^ ^^ ^^
+   |
+   = note: positional arguments are zero-based
+
+error: there is no argument named `foo`
+  --> $DIR/ifmt-bad-arg.rs:37:17
+   |
+LL |     format!("{} {foo} {} {bar} {}", 1, 2, 3);
+   |                 ^^^^^
+
+error: there is no argument named `bar`
+  --> $DIR/ifmt-bad-arg.rs:37:26
+   |
+LL |     format!("{} {foo} {} {bar} {}", 1, 2, 3);
+   |                          ^^^^^
+
+error: there is no argument named `foo`
+  --> $DIR/ifmt-bad-arg.rs:41:14
+   |
+LL |     format!("{foo}");                //~ ERROR: no argument named `foo`
+   |              ^^^^^
+
+error: multiple unused formatting arguments
+  --> $DIR/ifmt-bad-arg.rs:42:17
+   |
+LL |     format!("", 1, 2);               //~ ERROR: multiple unused formatting arguments
+   |             --  ^  ^
+   |             |
+   |             multiple missing formatting specifiers
+
+error: argument never used
+  --> $DIR/ifmt-bad-arg.rs:43:22
+   |
+LL |     format!("{}", 1, 2);             //~ ERROR: argument never used
+   |             ----     ^
+   |             |
+   |             formatting specifier missing
+
+error: argument never used
+  --> $DIR/ifmt-bad-arg.rs:44:20
+   |
+LL |     format!("{1}", 1, 2);            //~ ERROR: argument never used
+   |             -----  ^
+   |             |
+   |             formatting specifier missing
+
+error: named argument never used
+  --> $DIR/ifmt-bad-arg.rs:45:26
+   |
+LL |     format!("{}", 1, foo=2);         //~ ERROR: named argument never used
+   |             ----         ^
+   |             |
+   |             formatting specifier missing
+
+error: argument never used
+  --> $DIR/ifmt-bad-arg.rs:46:22
+   |
+LL |     format!("{foo}", 1, foo=2);      //~ ERROR: argument never used
+   |             -------  ^
+   |             |
+   |             formatting specifier missing
+
+error: named argument never used
+  --> $DIR/ifmt-bad-arg.rs:47:21
+   |
+LL |     format!("", foo=2);              //~ ERROR: named argument never used
+   |             --      ^
+   |             |
+   |             formatting specifier missing
+
+error: multiple unused formatting arguments
+  --> $DIR/ifmt-bad-arg.rs:48:32
+   |
+LL |     format!("{} {}", 1, 2, foo=1, bar=2);  //~ ERROR: multiple unused formatting arguments
+   |             -------            ^      ^
+   |             |
+   |             multiple missing formatting specifiers
+
+error: duplicate argument named `foo`
+  --> $DIR/ifmt-bad-arg.rs:50:33
+   |
+LL |     format!("{foo}", foo=1, foo=2);  //~ ERROR: duplicate argument
+   |                                 ^
+   |
+note: previously here
+  --> $DIR/ifmt-bad-arg.rs:50:26
+   |
+LL |     format!("{foo}", foo=1, foo=2);  //~ ERROR: duplicate argument
+   |                          ^
+
+error: expected ident, positional arguments cannot follow named arguments
+  --> $DIR/ifmt-bad-arg.rs:51:24
+   |
+LL |     format!("", foo=1, 2);           //~ ERROR: positional arguments cannot follow
+   |                        ^
+
+error: there is no argument named `valueb`
+  --> $DIR/ifmt-bad-arg.rs:55:23
+   |
+LL |     format!("{valuea} {valueb}", valuea=5, valuec=7);
+   |                       ^^^^^^^^
+
+error: named argument never used
+  --> $DIR/ifmt-bad-arg.rs:55:51
+   |
+LL |     format!("{valuea} {valueb}", valuea=5, valuec=7);
+   |             -------------------                   ^
+   |             |
+   |             formatting specifier missing
+
+error: invalid format string: expected `'}'` but string was terminated
+  --> $DIR/ifmt-bad-arg.rs:61:15
+   |
+LL |     format!("{"); //~ ERROR: expected `'}'` but string was terminated
+   |               ^ expected `'}'` in format string
+   |
+   = note: if you intended to print `{`, you can escape it using `{{`
+
+error: invalid format string: unmatched `}` found
+  --> $DIR/ifmt-bad-arg.rs:63:18
+   |
+LL |     format!("foo } bar"); //~ ERROR: unmatched `}` found
+   |                  ^ unmatched `}` in format string
+   |
+   = note: if you intended to print `}`, you can escape it using `}}`
+
+error: invalid format string: unmatched `}` found
+  --> $DIR/ifmt-bad-arg.rs:64:18
+   |
+LL |     format!("foo }"); //~ ERROR: unmatched `}` found
+   |                  ^ unmatched `}` in format string
+   |
+   = note: if you intended to print `}`, you can escape it using `}}`
+
+error: argument never used
+  --> $DIR/ifmt-bad-arg.rs:66:27
+   |
+LL |     format!("foo %s baz", "bar"); //~ ERROR: argument never used
+   |                  --       ^^^^^
+   |                  |
+   |                  help: format specifiers use curly braces: `{}`
+   |
+   = note: printf formatting not supported; see the documentation for `std::fmt`
+
+error: there is no argument named `foo`
+  --> $DIR/ifmt-bad-arg.rs:70:9
+   |
+LL |         {foo}
+   |         ^^^^^
+
+error: aborting due to 27 previous errors
+

src/test/ui/issue-12470.nll.stderr

@@ -5,7 +5,7 @@ LL |     let bb: &B = &*b;    //~ ERROR does not live long enough
    |                  ^^^ borrowed value does not live long enough
 LL |     make_a(bb)
 LL | }
-   | - borrowed value only lives until here
+   | - `*b` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 36:16...
   --> $DIR/issue-12470.rs:36:16

src/test/ui/issue-13497-2.nll.stderr

@@ -0,0 +1,18 @@
+error[E0597]: `rawLines` does not live long enough
+  --> $DIR/issue-13497-2.rs:13:5
+   |
+LL |     rawLines //~ ERROR `rawLines` does not live long enough
+   |     ^^^^^^^^ borrowed value does not live long enough
+LL |         .iter().map(|l| l.trim()).collect()
+LL | }
+   | - `rawLines` dropped here while still borrowed
+   |
+note: borrowed value must be valid for the lifetime 'a as defined on the function body at 11:24...
+  --> $DIR/issue-13497-2.rs:11:24
+   |
+LL | fn read_lines_borrowed<'a>() -> Vec<&'a str> {
+   |                        ^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0597`.

src/test/ui/issue-17954.ast.nll.stderr

@@ -5,7 +5,7 @@ LL |     let a = &FOO;
    |             ^^^^ borrowed value does not live long enough
 ...
 LL | }
-   | - borrowed value only lives until here
+   | - `FOO` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/issue-17954.mir.stderr

@@ -5,7 +5,7 @@ LL |     let a = &FOO;
    |             ^^^^ borrowed value does not live long enough
 ...
 LL | }
-   | - borrowed value only lives until here
+   | - `FOO` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/issue-17954.rs

@@ -29,5 +29,5 @@ fn main() {
         println!("{}", a);
     });
 }
-//[mir]~^ borrowed value only lives until here
+//[mir]~^ `FOO` dropped here while still borrowed
 //[ast]~^^ temporary value only lives until here

src/test/ui/issue-18118.nll.stderr

@@ -57,7 +57,7 @@ LL |         &p //~ ERROR `p` does not live long enough
    |         ^^ borrowed value does not live long enough
 LL |         //~^ ERROR let bindings in constants are unstable
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `p` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/issue-30438-c.nll.stderr

@@ -5,7 +5,7 @@ LL |     &x
    |     ^^ borrowed value does not live long enough
 LL |     //~^ ERROR: `x` does not live long enough
 LL | }
-   | - borrowed value only lives until here
+   | - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'y as defined on the function body at 17:10...
   --> $DIR/issue-30438-c.rs:17:10

src/test/ui/issue-42060.rs

@@ -0,0 +1,22 @@
+// 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.
+
+fn main() {
+    let thing = ();
+    let other: typeof(thing) = thing; //~ ERROR attempt to use a non-constant value in a constant
+    //~^ ERROR `typeof` is a reserved keyword but unimplemented [E0516]
+}
+
+fn f(){
+    let q = 1;
+    <typeof(q)>::N //~ ERROR attempt to use a non-constant value in a constant
+    //~^ ERROR `typeof` is a reserved keyword but unimplemented [E0516]
+}
+

src/test/ui/issue-42060.stderr

@@ -0,0 +1,28 @@
+error[E0435]: attempt to use a non-constant value in a constant
+  --> $DIR/issue-42060.rs:13:23
+   |
+LL |     let other: typeof(thing) = thing; //~ ERROR attempt to use a non-constant value in a constant
+   |                       ^^^^^ non-constant value
+
+error[E0435]: attempt to use a non-constant value in a constant
+  --> $DIR/issue-42060.rs:19:13
+   |
+LL |     <typeof(q)>::N //~ ERROR attempt to use a non-constant value in a constant
+   |             ^ non-constant value
+
+error[E0516]: `typeof` is a reserved keyword but unimplemented
+  --> $DIR/issue-42060.rs:13:16
+   |
+LL |     let other: typeof(thing) = thing; //~ ERROR attempt to use a non-constant value in a constant
+   |                ^^^^^^^^^^^^^ reserved keyword
+
+error[E0516]: `typeof` is a reserved keyword but unimplemented
+  --> $DIR/issue-42060.rs:19:6
+   |
+LL |     <typeof(q)>::N //~ ERROR attempt to use a non-constant value in a constant
+   |      ^^^^^^^^^ reserved keyword
+
+error: aborting due to 4 previous errors
+
+Some errors occurred: E0435, E0516.
+For more information about an error, try `rustc --explain E0435`.

src/test/ui/issue-43196.rs

@@ -0,0 +1,17 @@
+// 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.
+
+fn main() {
+    |
+}
+//~^ ERROR expected `|`, found `}`
+|
+//~^ ERROR expected item, found `|`
+

src/test/ui/issue-43196.stderr

@@ -0,0 +1,16 @@
+error: expected `|`, found `}`
+  --> $DIR/issue-43196.rs:13:1
+   |
+LL |     |
+   |      - expected `|` here
+LL | }
+   | ^ unexpected token
+
+error: expected item, found `|`
+  --> $DIR/issue-43196.rs:15:1
+   |
+LL | |
+   | ^ expected item
+
+error: aborting due to 2 previous errors
+

src/test/ui/issue-4335.nll.stderr

@@ -11,7 +11,7 @@ LL |     id(Box::new(|| *v))
    |                 ^^^^^ borrowed value does not live long enough
 ...
 LL | }
-   | - borrowed value only lives until here
+   | - `v` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'r as defined on the function body at 15:6...
   --> $DIR/issue-4335.rs:15:6

src/test/ui/issue-46036.stderr

@@ -5,7 +5,7 @@ LL |     let foo = Foo { x: &a }; //~ ERROR E0597
    |                        ^^ borrowed value does not live long enough
 LL |     loop { }
 LL | }
-   | - borrowed value only lives until here
+   | - `a` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/issue-46471-1.stderr

@@ -20,7 +20,7 @@ LL | |         &mut z
 LL | |     };
    | |     -
    | |     |
-   | |_____borrowed value only lives until here
+   | |_____`z` dropped here while still borrowed
    |       borrow later used here
 
 error: aborting due to 2 previous errors

src/test/ui/issue-46471.stderr

@@ -16,7 +16,7 @@ LL |     &x
    |     ^^ borrowed value does not live long enough
 ...
 LL | }
-   | - borrowed value only lives until here
+   | - `x` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/issue-52126-assign-op-invariance.nll.stderr

@@ -8,7 +8,7 @@ LL |         println!("accumulator before add_assign {:?}", acc.map);
    |                                                        ------- borrow later used here
 ...
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `line` dropped here while still borrowed
 
 error: aborting due to previous error
 

src/test/ui/macros/format-foreign.rs

@@ -11,6 +11,11 @@
 fn main() {
     println!("%.*3$s %s!\n", "Hello,", "World", 4); //~ ERROR multiple unused formatting arguments
     println!("%1$*2$.*3$f", 123.456); //~ ERROR never used
+    println!(r###"%.*3$s
+        %s!\n
+"###, "Hello,", "World", 4);
+    //~^ ERROR multiple unused formatting arguments
+    // correctly account for raw strings in inline suggestions
 
     // This should *not* produce hints, on the basis that there's equally as
     // many "correct" format specifiers.  It's *probably* just an actual typo.

src/test/ui/macros/format-foreign.stderr

@@ -4,29 +4,52 @@ error: multiple unused formatting arguments
 LL |     println!("%.*3$s %s!/n", "Hello,", "World", 4); //~ ERROR multiple unused formatting arguments
    |              --------------  ^^^^^^^^  ^^^^^^^  ^
    |              |
-   |              multiple missing formatting arguments
+   |              multiple missing formatting specifiers
    |
-   = help: `%.*3$s` should be written as `{:.2$}`
-   = help: `%s` should be written as `{}`
    = note: printf formatting not supported; see the documentation for `std::fmt`
+help: format specifiers use curly braces
+   |
+LL |     println!("{:.2$} {}!/n", "Hello,", "World", 4); //~ ERROR multiple unused formatting arguments
+   |               ^^^^^^ ^^
 
 error: argument never used
   --> $DIR/format-foreign.rs:13:29
    |
 LL |     println!("%1$*2$.*3$f", 123.456); //~ ERROR never used
-   |                             ^^^^^^^
+   |               -----------   ^^^^^^^
+   |               |
+   |               help: format specifiers use curly braces: `{0:1$.2$}`
    |
-   = help: `%1$*2$.*3$f` should be written as `{0:1$.2$}`
    = note: printf formatting not supported; see the documentation for `std::fmt`
 
+error: multiple unused formatting arguments
+  --> $DIR/format-foreign.rs:16:7
+   |
+LL |       println!(r###"%.*3$s
+   |  ______________-
+LL | |         %s!/n
+LL | | "###, "Hello,", "World", 4);
+   | |    -  ^^^^^^^^  ^^^^^^^  ^
+   | |____|
+   |      multiple missing formatting specifiers
+   |
+   = note: printf formatting not supported; see the documentation for `std::fmt`
+help: format specifiers use curly braces
+   |
+LL |     println!(r###"{:.2$}
+LL |         {}!/n
+   |
+
 error: argument never used
-  --> $DIR/format-foreign.rs:17:30
+  --> $DIR/format-foreign.rs:22:30
    |
 LL |     println!("{} %f", "one", 2.0); //~ ERROR never used
-   |                              ^^^
+   |              -------         ^^^
+   |              |
+   |              formatting specifier missing
 
 error: named argument never used
-  --> $DIR/format-foreign.rs:19:39
+  --> $DIR/format-foreign.rs:24:39
    |
 LL |     println!("Hi there, $NAME.", NAME="Tim"); //~ ERROR never used
    |                                       ^^^^^
@@ -34,5 +57,5 @@ LL |     println!("Hi there, $NAME.", NAME="Tim"); //~ ERROR never used
    = help: `$NAME` should be written as `{NAME}`
    = note: shell formatting not supported; see the documentation for `std::fmt`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 

src/test/ui/macros/format-unused-lables.stderr

@@ -4,13 +4,13 @@ error: multiple unused formatting arguments
 LL |     println!("Test", 123, 456, 789);
    |              ------  ^^^  ^^^  ^^^
    |              |
-   |              multiple missing formatting arguments
+   |              multiple missing formatting specifiers
 
 error: multiple unused formatting arguments
   --> $DIR/format-unused-lables.rs:16:9
    |
 LL |     println!("Test2",
-   |              ------- multiple missing formatting arguments
+   |              ------- multiple missing formatting specifiers
 LL |         123,  //~ ERROR multiple unused formatting arguments
    |         ^^^
 LL |         456,
@@ -22,13 +22,15 @@ error: named argument never used
   --> $DIR/format-unused-lables.rs:21:35
    |
 LL |     println!("Some stuff", UNUSED="args"); //~ ERROR named argument never used
-   |                                   ^^^^^^
+   |              ------------         ^^^^^^
+   |              |
+   |              formatting specifier missing
 
 error: multiple unused formatting arguments
   --> $DIR/format-unused-lables.rs:24:9
    |
 LL |     println!("Some more $STUFF",
-   |              ------------------ multiple missing formatting arguments
+   |              ------------------ multiple missing formatting specifiers
 LL |         "woo!",  //~ ERROR multiple unused formatting arguments
    |         ^^^^^^
 LL |             STUFF=

src/test/ui/mismatched_types/closure-arg-count.stderr

@@ -5,6 +5,10 @@ LL |     [1, 2, 3].sort_by(|| panic!());
    |               ^^^^^^^ -- takes 0 arguments
    |               |
    |               expected closure that takes 2 arguments
+help: consider changing the closure to take and ignore the expected arguments
+   |
+LL |     [1, 2, 3].sort_by(|_, _| panic!());
+   |                       ^^^^^^
 
 error[E0593]: closure is expected to take 2 arguments, but it takes 1 argument
   --> $DIR/closure-arg-count.rs:17:15
@@ -51,6 +55,10 @@ note: required by `f`
    |
 LL | fn f<F: Fn<usize>>(_: F) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the closure to take and ignore the expected argument
+   |
+LL |     f(|_| panic!());
+   |       ^^^
 
 error[E0593]: closure is expected to take a single 2-tuple as argument, but it takes 2 distinct arguments
   --> $DIR/closure-arg-count.rs:26:53

src/test/ui/nll/borrowed-local-error.stderr

@@ -10,7 +10,7 @@ LL | |         //~^ ERROR `v` does not live long enough [E0597]
 LL | |     });
    | |_____-- borrow later used here
    |       |
-   |       borrowed value only lives until here
+   |       `v` dropped here while still borrowed
 
 error: aborting due to previous error
 

src/test/ui/nll/borrowed-universal-error-2.stderr

@@ -5,7 +5,7 @@ LL |     &v
    |     ^^ borrowed value does not live long enough
 LL |     //~^ ERROR `v` does not live long enough [E0597]
 LL | }
-   | - borrowed value only lives until here
+   | - `v` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 14:8...
   --> $DIR/borrowed-universal-error-2.rs:14:8

src/test/ui/nll/capture-ref-in-struct.stderr

@@ -5,7 +5,7 @@ LL |             y: &y,
    |                ^^ borrowed value does not live long enough
 ...
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `y` dropped here while still borrowed
 LL | 
 LL |     deref(p);
    |           - borrow later used here

src/test/ui/nll/closure-requirements/escape-argument.stderr

@@ -30,7 +30,7 @@ LL |         closure(&mut p, &y);
    |                         ^^ borrowed value does not live long enough
 LL |         //~^ ERROR `y` does not live long enough [E0597]
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `y` dropped here while still borrowed
 LL | 
 LL |     deref(p);
    |           - borrow later used here

src/test/ui/nll/closure-requirements/escape-upvar-nested.stderr

@@ -57,7 +57,7 @@ LL | |         };
    | |_________^ borrowed value does not live long enough
 ...
 LL |       }
-   |       - borrowed value only lives until here
+   |       - `y` dropped here while still borrowed
 LL | 
 LL |       deref(p);
    |             - borrow later used here

src/test/ui/nll/closure-requirements/escape-upvar-ref.stderr

@@ -34,7 +34,7 @@ LL |         let mut closure = || p = &y;
    |                           ^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `y` dropped here while still borrowed
 LL | 
 LL |     deref(p);
    |           - borrow later used here

src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr

@@ -82,7 +82,7 @@ LL |     let cell = Cell::new(&a);
    |                          ^^ borrowed value does not live long enough
 ...
 LL | }
-   | - borrowed value only lives until here
+   | - `a` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/nll/issue-31567.stderr

@@ -5,7 +5,7 @@ LL |     let s_inner: &'a S = &*v.0; //~ ERROR `*v.0` does not live long enough
    |                          ^^^^^ borrowed value does not live long enough
 LL |     &s_inner.0
 LL | }
-   | - borrowed value only lives until here
+   | - `*v.0` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 21:17...
   --> $DIR/issue-31567.rs:21:17

src/test/ui/nll/issue-47470.stderr

@@ -4,7 +4,7 @@ error[E0597]: `local` does not live long enough
 LL |         &local //~ ERROR `local` does not live long enough
    |         ^^^^^^ borrowed value does not live long enough
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `local` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the impl at 23:6...
   --> $DIR/issue-47470.rs:23:6

src/test/ui/region-borrow-params-issue-29793-small.nll.stderr

@@ -5,7 +5,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |      - borrowed value only lives until here
+   |      - `x` dropped here while still borrowed
 
 error[E0597]: `y` does not live long enough
   --> $DIR/region-borrow-params-issue-29793-small.rs:19:17
@@ -14,7 +14,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |      - borrowed value only lives until here
+   |      - `y` dropped here while still borrowed
 
 error[E0597]: `x` does not live long enough
   --> $DIR/region-borrow-params-issue-29793-small.rs:34:17
@@ -23,7 +23,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |      - borrowed value only lives until here
+   |      - `x` dropped here while still borrowed
 
 error[E0597]: `y` does not live long enough
   --> $DIR/region-borrow-params-issue-29793-small.rs:34:17
@@ -32,7 +32,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |      - borrowed value only lives until here
+   |      - `y` dropped here while still borrowed
 
 error[E0597]: `x` does not live long enough
   --> $DIR/region-borrow-params-issue-29793-small.rs:65:17
@@ -41,7 +41,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 64:10...
   --> $DIR/region-borrow-params-issue-29793-small.rs:64:10
@@ -56,7 +56,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 64:10...
   --> $DIR/region-borrow-params-issue-29793-small.rs:64:10
@@ -71,7 +71,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 75:10...
   --> $DIR/region-borrow-params-issue-29793-small.rs:75:10
@@ -86,7 +86,7 @@ LL |         let f = |t: bool| if t { x } else { y }; // (separate errors for `x
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the function body at 75:10...
   --> $DIR/region-borrow-params-issue-29793-small.rs:75:10
@@ -101,7 +101,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 99:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:99:14
@@ -116,7 +116,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 99:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:99:14
@@ -131,7 +131,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 113:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:113:14
@@ -146,7 +146,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 113:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:113:14
@@ -161,7 +161,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 141:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:141:14
@@ -176,7 +176,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 141:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:141:14
@@ -191,7 +191,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 156:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:156:14
@@ -206,7 +206,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 156:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:156:14
@@ -221,7 +221,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 184:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:184:14
@@ -236,7 +236,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 184:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:184:14
@@ -251,7 +251,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `x` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 198:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:198:14
@@ -266,7 +266,7 @@ LL |             let f = |t: bool| if t { x } else { y }; // (separate errors fo
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
 ...
 LL |         }
-   |         - borrowed value only lives until here
+   |         - `y` dropped here while still borrowed
    |
 note: borrowed value must be valid for the lifetime 'a as defined on the method body at 198:14...
   --> $DIR/region-borrow-params-issue-29793-small.rs:198:14

src/test/ui/regions-nested-fns-2.nll.stderr

@@ -7,7 +7,7 @@ LL | |             if false { &y } else { z }
 LL | |         });
    | |_________^ borrowed value does not live long enough
 LL |   }
-   |   - borrowed value only lives until here
+   |   - `y` dropped here while still borrowed
    |
    = note: borrowed value must be valid for the static lifetime...
 

src/test/ui/span/destructor-restrictions.nll.stderr

@@ -4,7 +4,7 @@ error[E0597]: `*a` does not live long enough
 LL |         *a.borrow() + 1
    |          ^ borrowed value does not live long enough
 LL |     }; //~^ ERROR `*a` does not live long enough
-   |     - borrowed value only lives until here
+   |     - `*a` dropped here while still borrowed
 
 error: aborting due to previous error
 

src/test/ui/span/dropck-object-cycle.nll.stderr

@@ -7,7 +7,7 @@ LL |     assert_eq!(object_invoke1(&*m), (4,5));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `*m` dropped here while still borrowed
    | borrow later used here, when `m` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/dropck_arr_cycle_checked.nll.stderr

@@ -7,7 +7,7 @@ LL |     b1.a[1].v.set(Some(&b3));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `b3` dropped here while still borrowed
    | borrow later used here, when `b1` is dropped
 
 error[E0597]: `b2` does not live long enough
@@ -19,7 +19,7 @@ LL |     b1.a[0].v.set(Some(&b2));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `b2` dropped here while still borrowed
    | borrow later used here, when `b1` is dropped
 
 error[E0597]: `b1` does not live long enough
@@ -31,7 +31,7 @@ LL |     b3.a[0].v.set(Some(&b1));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `b1` dropped here while still borrowed
    | borrow later used here, when `b1` is dropped
 
 error: aborting due to 3 previous errors

src/test/ui/span/dropck_direct_cycle_with_drop.nll.stderr

@@ -7,7 +7,7 @@ LL |     d1.p.set(Some(&d2));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d2` dropped here while still borrowed
    | borrow later used here, when `d1` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined
@@ -21,7 +21,7 @@ LL |     //~^ ERROR `d1` does not live long enough
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d1` dropped here while still borrowed
    | borrow later used here, when `d1` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/dropck_misc_variants.nll.stderr

@@ -6,7 +6,7 @@ LL |     _w = Wrap::<&[&str]>(NoisyDrop(&bomb));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `bomb` dropped here while still borrowed
    | borrow later used here, when `_w` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined
@@ -20,7 +20,7 @@ LL |         let u = NoisyDrop(&v);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `v` dropped here while still borrowed
    | borrow later used here, when `_w` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/dropck_vec_cycle_checked.nll.stderr

@@ -7,7 +7,7 @@ LL |     c1.v[1].v.set(Some(&c3));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `c3` dropped here while still borrowed
    | borrow later used here, when `c1` is dropped
 
 error[E0597]: `c2` does not live long enough
@@ -19,7 +19,7 @@ LL |     c1.v[0].v.set(Some(&c2));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `c2` dropped here while still borrowed
    | borrow later used here, when `c1` is dropped
 
 error[E0597]: `c1` does not live long enough
@@ -31,7 +31,7 @@ LL |     c3.v[0].v.set(Some(&c1));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `c1` dropped here while still borrowed
    | borrow later used here, when `c1` is dropped
 
 error: aborting due to 3 previous errors

src/test/ui/span/issue-11925.nll.stderr

@@ -4,7 +4,7 @@ error[E0597]: `x` does not live long enough
 LL |         let f = to_fn_once(move|| &x); //~ ERROR does not live long enough
    |                                   ^-
    |                                   ||
-   |                                   |borrowed value only lives until here
+   |                                   |`x` dropped here while still borrowed
    |                                   borrowed value does not live long enough
 
 error: aborting due to previous error

src/test/ui/span/issue-23338-locals-die-before-temps-of-body.nll.stderr

@@ -4,7 +4,7 @@ error[E0597]: `y` does not live long enough
 LL |     y.borrow().clone()
    |     ^ borrowed value does not live long enough
 LL | }
-   | - borrowed value only lives until here
+   | - `y` dropped here while still borrowed
 
 error[E0597]: `y` does not live long enough
   --> $DIR/issue-23338-locals-die-before-temps-of-body.rs:27:9
@@ -12,7 +12,7 @@ error[E0597]: `y` does not live long enough
 LL |         y.borrow().clone()
    |         ^ borrowed value does not live long enough
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `y` dropped here while still borrowed
 
 error: aborting due to 2 previous errors
 

src/test/ui/span/issue-24805-dropck-child-has-items-via-parent.nll.stderr

@@ -7,7 +7,7 @@ LL |     _d = D_Child(&d1);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d1` dropped here while still borrowed
    | borrow later used here, when `_d` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue-24805-dropck-trait-has-items.nll.stderr

@@ -6,7 +6,7 @@ LL |     _d = D_HasSelfMethod(&d1);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d1` dropped here while still borrowed
    | borrow later used here, when `_d` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined
@@ -19,7 +19,7 @@ LL |     _d = D_HasMethodWithSelfArg(&d1);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d1` dropped here while still borrowed
    | borrow later used here, when `_d` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined
@@ -32,7 +32,7 @@ LL |     _d = D_HasType(&d1);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d1` dropped here while still borrowed
    | borrow later used here, when `_d` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue-24895-copy-clone-dropck.nll.stderr

@@ -6,7 +6,7 @@ LL |     d2 = D(S(&d1, "inner"), "d2");
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `d1` dropped here while still borrowed
    | borrow later used here, when `d2` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue-25199.nll.stderr

@@ -7,7 +7,7 @@ LL |     let test = Test{test: &container};
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `container` dropped here while still borrowed
    | borrow later used here, when `container` is dropped
 
 error: aborting due to previous error

src/test/ui/span/issue-26656.nll.stderr

@@ -6,7 +6,7 @@ LL |     zook.button = B::BigRedButton(&ticking);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `ticking` dropped here while still borrowed
    | borrow later used here, when `zook` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue-29106.nll.stderr

@@ -6,7 +6,7 @@ LL |         y = Arc::new(Foo(&x));
 LL |     }
    |     -
    |     |
-   |     borrowed value only lives until here
+   |     `x` dropped here while still borrowed
    |     borrow later used here, when `y` is dropped
 
 error[E0597]: `x` does not live long enough
@@ -17,7 +17,7 @@ LL |         y = Rc::new(Foo(&x));
 LL |     }
    |     -
    |     |
-   |     borrowed value only lives until here
+   |     `x` dropped here while still borrowed
    |     borrow later used here, when `y` is dropped
 
 error: aborting due to 2 previous errors

src/test/ui/span/issue-36537.nll.stderr

@@ -5,7 +5,7 @@ LL |         p = &a;
    |         ^^^^^^ borrowed value does not live long enough
 ...
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `a` dropped here while still borrowed
 LL |     p.use_ref();
    |     - borrow later used here
 

src/test/ui/span/issue-40157.nll.stderr

@@ -4,7 +4,7 @@ error[E0597]: `foo` does not live long enough
 LL |     {println!("{:?}", match { let foo = vec![1, 2]; foo.get(1) } { x => x });}
    |                       ------------------------------^^^--------------------
    |                       |                             |          |
-   |                       |                             |          borrowed value only lives until here
+   |                       |                             |          `foo` dropped here while still borrowed
    |                       |                             borrowed value does not live long enough
    |                       borrow later used here
 

src/test/ui/span/issue28498-reject-ex1.nll.stderr

@@ -7,7 +7,7 @@ LL |     foo.data[0].1.set(Some(&foo.data[1]));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `foo.data` dropped here while still borrowed
    | borrow later used here, when `foo` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue28498-reject-lifetime-param.nll.stderr

@@ -7,7 +7,7 @@ LL |     foo1 = Foo(1, &first_dropped);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `first_dropped` dropped here while still borrowed
    | borrow later used here, when `foo1` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue28498-reject-passed-to-fn.nll.stderr

@@ -7,7 +7,7 @@ LL |     foo1 = Foo(1, &first_dropped, Box::new(callback));
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `first_dropped` dropped here while still borrowed
    | borrow later used here, when `foo1` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/issue28498-reject-trait-bound.nll.stderr

@@ -7,7 +7,7 @@ LL |     foo1 = Foo(1, &first_dropped);
 LL | }
    | -
    | |
-   | borrowed value only lives until here
+   | `first_dropped` dropped here while still borrowed
    | borrow later used here, when `foo1` is dropped
    |
    = note: values in a scope are dropped in the opposite order they are defined

src/test/ui/span/mut-ptr-cant-outlive-ref.nll.stderr

@@ -4,7 +4,7 @@ error[E0597]: `b` does not live long enough
 LL |         p = &*b;
    |               ^ borrowed value does not live long enough
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `b` dropped here while still borrowed
 LL |     //~^^ ERROR `b` does not live long enough
 LL |     p.use_ref();
    |     - borrow later used here

src/test/ui/span/range-2.nll.stderr

@@ -4,7 +4,7 @@ error[E0597]: `b` does not live long enough
 LL |         &a..&b
    |             ^^ borrowed value does not live long enough
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `b` dropped here while still borrowed
 ...
 LL |     r.use_ref();
    |     - borrow later used here
@@ -15,7 +15,7 @@ error[E0597]: `a` does not live long enough
 LL |         &a..&b
    |         ^^ borrowed value does not live long enough
 LL |     };
-   |     - borrowed value only lives until here
+   |     - `a` dropped here while still borrowed
 ...
 LL |     r.use_ref();
    |     - borrow later used here

src/test/ui/span/regionck-unboxed-closure-lifetimes.nll.stderr

@@ -5,7 +5,7 @@ LL |         let c_ref = &c;
    |                     ^^ borrowed value does not live long enough
 ...
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `c` dropped here while still borrowed
 LL |     f.use_mut();
    |     - borrow later used here
 

src/test/ui/span/regions-close-over-type-parameter-2.nll.stderr

@@ -10,7 +10,7 @@ LL | |         repeater3(tmp1)
 LL | |     };
    | |     -
    | |     |
-   | |_____borrowed value only lives until here
+   | |_____`tmp0` dropped here while still borrowed
    |       borrow later used here
 
 error: aborting due to previous error

src/test/ui/span/regions-escape-loop-via-variable.nll.stderr

@@ -6,7 +6,7 @@ LL |         let x = 1 + *p;
 LL |         p = &x;
    |             ^^ borrowed value does not live long enough
 LL |     }
-   |     - borrowed value only lives until here
+   |     - `x` dropped here while still borrowed
 
 error: aborting due to previous error