From 7d91039ac06dc34795cb141b53b610e10cbc1340 Mon Sep 17 00:00:00 2001
From: William Venner <william@venner.io>
Date: Tue, 5 Jul 2022 17:19:03 +0100
Subject: [PATCH 01/71] Add `BufRead::skip_until`

---
 library/std/src/io/mod.rs | 84 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index f4f2e3f2434..a5dab49c75d 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -1923,6 +1923,28 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>) -> R
     }
 }
 
+fn skip_until<R: BufRead + ?Sized>(r: &mut R, delim: u8) -> Result<usize> {
+    let mut read = 0;
+    loop {
+        let (done, used) = {
+            let available = match r.fill_buf() {
+                Ok(n) => n,
+                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
+                Err(e) => return Err(e),
+            };
+            match memchr::memchr(delim, available) {
+                Some(i) => (true, i + 1),
+                None => (false, available.len()),
+            }
+        };
+        r.consume(used);
+        read += used;
+        if done || used == 0 {
+            return Ok(read);
+        }
+    }
+}
+
 /// A `BufRead` is a type of `Read`er which has an internal buffer, allowing it
 /// to perform extra ways of reading.
 ///
@@ -2126,6 +2148,68 @@ pub trait BufRead: Read {
         read_until(self, byte, buf)
     }
 
+    /// Skip all bytes until the delimiter `byte` or EOF is reached.
+    ///
+    /// This function will read (and discard) bytes from the underlying stream until the
+    /// delimiter or EOF is found.
+    ///
+    /// If successful, this function will return the total number of bytes read,
+    /// including the delimiter byte.
+    ///
+    /// This is useful for efficiently skipping data such as NUL-terminated strings
+    /// in binary file formats without buffering.
+    ///
+    /// This function is blocking and should be used carefully: it is possible for
+    /// an attacker to continuously send bytes without ever sending the delimiter
+    /// or EOF.
+    ///
+    /// # Errors
+    ///
+    /// This function will ignore all instances of [`ErrorKind::Interrupted`] and
+    /// will otherwise return any errors returned by [`fill_buf`].
+    ///
+    /// If an I/O error is encountered then all bytes read so far will be
+    /// present in `buf` and its length will have been adjusted appropriately.
+    ///
+    /// [`fill_buf`]: BufRead::fill_buf
+    ///
+    /// # Examples
+    ///
+    /// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In
+    /// this example, we use [`Cursor`] to read some NUL-terminated information
+    /// about Ferris from a binary string, skipping the fun fact:
+    ///
+    /// ```
+    /// #![feature(bufread_skip_until)]
+    ///
+    /// use std::io::{self, BufRead};
+    ///
+    /// let mut cursor = io::Cursor::new(b"Ferris\0Likes long walks on the beach\0Crustacean\0");
+    ///
+    /// // read name
+    /// let mut name = Vec::new();
+    /// let num_bytes = cursor.read_until(b'\0', &mut name)
+    ///     .expect("reading from cursor won't fail");
+    /// assert_eq!(num_bytes, 7);
+    /// assert_eq!(name, b"Ferris\0");
+    ///
+    /// // skip fun fact
+    /// let num_bytes = cursor.skip_until(b'\0')
+    ///     .expect("reading from cursor won't fail");
+    /// assert_eq!(num_bytes, 30);
+    ///
+    /// // read animal type
+    /// let mut animal = Vec::new();
+    /// let num_bytes = cursor.read_until(b'\0', &mut animal)
+    ///     .expect("reading from cursor won't fail");
+    /// assert_eq!(num_bytes, 11);
+    /// assert_eq!(animal, b"Crustacean\0");
+    /// ```
+    #[unstable(feature = "bufread_skip_until", issue = "none")]
+    fn skip_until(&mut self, byte: u8) -> Result<usize> {
+        skip_until(self, byte)
+    }
+
     /// Read all bytes until a newline (the `0xA` byte) is reached, and append
     /// them to the provided buffer. You do not need to clear the buffer before
     /// appending.

From 4eea9763847250c89f535f6a8c3b0fd49d860e78 Mon Sep 17 00:00:00 2001
From: William Venner <william@venner.io>
Date: Thu, 18 May 2023 18:57:15 +0100
Subject: [PATCH 02/71] Add `BufRead::skip_until` test

---
 library/std/src/io/buffered/tests.rs | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/library/std/src/io/buffered/tests.rs b/library/std/src/io/buffered/tests.rs
index 9d429e7090e..ca5d8fb4b7f 100644
--- a/library/std/src/io/buffered/tests.rs
+++ b/library/std/src/io/buffered/tests.rs
@@ -400,6 +400,34 @@ fn test_read_until() {
     assert_eq!(v, []);
 }
 
+#[test]
+fn test_skip_until() {
+    let bytes: &[u8] = b"read\0ignore\0read\0ignore\0read\0ignore";
+    let mut reader = BufReader::new(bytes);
+
+    // read from the bytes, alternating between
+    // consuming `read\0`s and skipping `ignore\0`s
+    loop {
+        // consume `read\0`
+        let mut out = Vec::new();
+        let read = reader.read_until(0, &mut out).unwrap();
+        if read == 0 {
+            // eof
+            break;
+        } else {
+            assert_eq!(out, b"read\0");
+        }
+
+        // skip past `ignore\0`
+        reader.skip_until(0).unwrap();
+    }
+
+    // ensure we are at the end of the byte slice and that we can skip no further
+    // also ensure skip_until matches the behavior of read_until at EOF
+    let skipped = reader.skip_until(0).unwrap();
+    assert_eq!(skipped, 0);
+}
+
 #[test]
 fn test_line_buffer() {
     let mut writer = LineWriter::new(Vec::new());

From 7c9ad34362ab545dd5be75637afd84b6287507a0 Mon Sep 17 00:00:00 2001
From: William Venner <william@venner.io>
Date: Thu, 18 May 2023 18:59:36 +0100
Subject: [PATCH 03/71] Move `BufRead::skip_until` test to a more appropriate
 location

---
 library/std/src/io/buffered/tests.rs | 28 ----------------------------
 library/std/src/io/tests.rs          | 28 ++++++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/library/std/src/io/buffered/tests.rs b/library/std/src/io/buffered/tests.rs
index ca5d8fb4b7f..9d429e7090e 100644
--- a/library/std/src/io/buffered/tests.rs
+++ b/library/std/src/io/buffered/tests.rs
@@ -400,34 +400,6 @@ fn test_read_until() {
     assert_eq!(v, []);
 }
 
-#[test]
-fn test_skip_until() {
-    let bytes: &[u8] = b"read\0ignore\0read\0ignore\0read\0ignore";
-    let mut reader = BufReader::new(bytes);
-
-    // read from the bytes, alternating between
-    // consuming `read\0`s and skipping `ignore\0`s
-    loop {
-        // consume `read\0`
-        let mut out = Vec::new();
-        let read = reader.read_until(0, &mut out).unwrap();
-        if read == 0 {
-            // eof
-            break;
-        } else {
-            assert_eq!(out, b"read\0");
-        }
-
-        // skip past `ignore\0`
-        reader.skip_until(0).unwrap();
-    }
-
-    // ensure we are at the end of the byte slice and that we can skip no further
-    // also ensure skip_until matches the behavior of read_until at EOF
-    let skipped = reader.skip_until(0).unwrap();
-    assert_eq!(skipped, 0);
-}
-
 #[test]
 fn test_line_buffer() {
     let mut writer = LineWriter::new(Vec::new());
diff --git a/library/std/src/io/tests.rs b/library/std/src/io/tests.rs
index d5a8c93b0ce..9a9a790d77d 100644
--- a/library/std/src/io/tests.rs
+++ b/library/std/src/io/tests.rs
@@ -25,6 +25,34 @@ fn read_until() {
     assert_eq!(v, []);
 }
 
+#[test]
+fn skip_until() {
+    let bytes: &[u8] = b"read\0ignore\0read\0ignore\0read\0ignore";
+    let mut reader = BufReader::new(bytes);
+
+    // read from the bytes, alternating between
+    // consuming `read\0`s and skipping `ignore\0`s
+    loop {
+        // consume `read\0`
+        let mut out = Vec::new();
+        let read = reader.read_until(0, &mut out).unwrap();
+        if read == 0 {
+            // eof
+            break;
+        } else {
+            assert_eq!(out, b"read\0");
+        }
+
+        // skip past `ignore\0`
+        reader.skip_until(0).unwrap();
+    }
+
+    // ensure we are at the end of the byte slice and that we can skip no further
+    // also ensure skip_until matches the behavior of read_until at EOF
+    let skipped = reader.skip_until(0).unwrap();
+    assert_eq!(skipped, 0);
+}
+
 #[test]
 fn split() {
     let buf = Cursor::new(&b"12"[..]);

From 1d7d7654e686f0452f10e016ef78c3d4b191526e Mon Sep 17 00:00:00 2001
From: William Venner <william@venner.io>
Date: Thu, 18 May 2023 19:08:41 +0100
Subject: [PATCH 04/71] Add tracking issue ID for `bufread_skip_until` feature
 gate

---
 library/std/src/io/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index a5dab49c75d..2cbdd027036 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -2205,7 +2205,7 @@ pub trait BufRead: Read {
     /// assert_eq!(num_bytes, 11);
     /// assert_eq!(animal, b"Crustacean\0");
     /// ```
-    #[unstable(feature = "bufread_skip_until", issue = "none")]
+    #[unstable(feature = "bufread_skip_until", issue = "111735")]
     fn skip_until(&mut self, byte: u8) -> Result<usize> {
         skip_until(self, byte)
     }

From 7c1ab71f71087d88aade79925ae68a447397422f Mon Sep 17 00:00:00 2001
From: William Venner <william@venner.io>
Date: Thu, 3 Aug 2023 09:52:57 +0100
Subject: [PATCH 05/71] Add assertion to test `skip_until` return value

The extra `\0` in this commit is needed because the assertion on line 49 will fail otherwise (as `skip_until` stops reading on EOF and therefore does not read a trailing `\0`, returning 6 read bytes rather than the expected 7)
---
 library/std/src/io/tests.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/library/std/src/io/tests.rs b/library/std/src/io/tests.rs
index 9a9a790d77d..4c5f86fe431 100644
--- a/library/std/src/io/tests.rs
+++ b/library/std/src/io/tests.rs
@@ -27,7 +27,7 @@ fn read_until() {
 
 #[test]
 fn skip_until() {
-    let bytes: &[u8] = b"read\0ignore\0read\0ignore\0read\0ignore";
+    let bytes: &[u8] = b"read\0ignore\0read\0ignore\0read\0ignore\0";
     let mut reader = BufReader::new(bytes);
 
     // read from the bytes, alternating between
@@ -41,10 +41,12 @@ fn skip_until() {
             break;
         } else {
             assert_eq!(out, b"read\0");
+            assert_eq!(read, b"read\0".len());
         }
 
         // skip past `ignore\0`
-        reader.skip_until(0).unwrap();
+        let skipped = reader.skip_until(0).unwrap();
+        assert_eq!(skipped, b"ignore\0".len());
     }
 
     // ensure we are at the end of the byte slice and that we can skip no further

From 1fb00335df72fc3a05cd13a2bd5013f362d21177 Mon Sep 17 00:00:00 2001
From: Sean Linsley <code@seanlinsley.com>
Date: Mon, 16 Oct 2023 12:41:43 -0500
Subject: [PATCH 06/71] Improve rewind documentation

---
 library/std/src/io/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index c0a72948112..b7b6a9a24c9 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -556,6 +556,10 @@ where
 /// therefore, using something that implements [`BufRead`], such as
 /// [`BufReader`], will be more efficient.
 ///
+/// Repeated calls to the reader use the same cursor, so for example
+/// calling `read_to_end` twice on a [`File`] will only return the file's
+/// contents once. It's recommended to first call `rewind()` in that case.
+///
 /// # Examples
 ///
 /// [`File`]s implement `Read`:

From 5d3aefe58d2148d277a1b28e29caed0e48858a9f Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 14:46:28 +0900
Subject: [PATCH 07/71] kmc-solid: Add
 `std::os::solid::io::{BorrowedFd,OwnedFd,AsFd}`

It's mostly based on `std::os::fd::owned`.
---
 library/std/src/os/solid/io.rs | 191 +++++++++++++++++++++++++++++++++
 1 file changed, 191 insertions(+)

diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index f82034663d4..ab17a01e411 100644
--- a/library/std/src/os/solid/io.rs
+++ b/library/std/src/os/solid/io.rs
@@ -3,6 +3,9 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![unstable(feature = "solid_ext", issue = "none")]
 
+use crate::fmt;
+use crate::marker::PhantomData;
+use crate::mem::forget;
 use crate::net;
 use crate::sys;
 use crate::sys_common::{self, AsInner, FromInner, IntoInner};
@@ -10,6 +13,194 @@ use crate::sys_common::{self, AsInner, FromInner, IntoInner};
 /// Raw file descriptors.
 pub type RawFd = i32;
 
+/// A borrowed SOLID Sockets file descriptor.
+///
+/// This has a lifetime parameter to tie it to the lifetime of something that
+/// owns the socket.
+///
+/// This uses `repr(transparent)` and has the representation of a host file
+/// descriptor, so it can be used in FFI in places where a socket is passed as
+/// an argument, it is not captured or consumed, and it never has the value
+/// `SOLID_NET_INVALID_FD`.
+///
+/// This type's `.to_owned()` implementation returns another `BorrowedFd`
+/// rather than an `OwnedFd`. It just makes a trivial copy of the raw
+/// socket, which is then borrowed under the same lifetime.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+#[rustc_layout_scalar_valid_range_start(0)]
+// This is -2, in two's complement. -1 is `SOLID_NET_INVALID_FD`.
+#[rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)]
+#[rustc_nonnull_optimization_guaranteed]
+pub struct BorrowedFd<'socket> {
+    fd: RawFd,
+    _phantom: PhantomData<&'socket OwnedFd>,
+}
+
+/// An owned SOLID Sockets file descriptor.
+///
+/// This closes the file descriptor on drop.
+///
+/// This uses `repr(transparent)` and has the representation of a host file
+/// descriptor, so it can be used in FFI in places where a socket is passed as
+/// an argument, it is not captured or consumed, and it never has the value
+/// `SOLID_NET_INVALID_FD`.
+#[repr(transparent)]
+#[rustc_layout_scalar_valid_range_start(0)]
+// This is -2, in two's complement. -1 is `SOLID_NET_INVALID_FD`.
+#[rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)]
+#[rustc_nonnull_optimization_guaranteed]
+pub struct OwnedFd {
+    fd: RawFd,
+}
+
+impl BorrowedFd<'_> {
+    /// Return a `BorrowedFd` holding the given raw file descriptor.
+    ///
+    /// # Safety
+    ///
+    /// The resource pointed to by `fd` must remain open for the duration of
+    /// the returned `BorrowedFd`, and it must not have the value
+    /// `SOLID_NET_INVALID_FD`.
+    #[inline]
+    pub const unsafe fn borrow_raw(fd: RawFd) -> Self {
+        assert!(fd != -1 as RawFd);
+        // SAFETY: we just asserted that the value is in the valid range and
+        // isn't `-1` (the only value bigger than `0xFF_FF_FF_FE` unsigned)
+        unsafe { Self { fd, _phantom: PhantomData } }
+    }
+}
+
+impl OwnedFd {
+    /// Creates a new `OwnedFd` instance that shares the same underlying file
+    /// description as the existing `OwnedFd` instance.
+    pub fn try_clone(&self) -> crate::io::Result<Self> {
+        self.as_fd().try_clone_to_owned()
+    }
+}
+
+impl BorrowedFd<'_> {
+    /// Creates a new `OwnedFd` instance that shares the same underlying file
+    /// description as the existing `BorrowedFd` instance.
+    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
+        let fd = sys::net::cvt(unsafe { sys::net::netc::dup(self.as_raw_fd()) })?;
+        Ok(unsafe { OwnedFd::from_raw_fd(fd) })
+    }
+}
+
+impl AsRawFd for BorrowedFd<'_> {
+    #[inline]
+    fn as_raw_fd(&self) -> RawFd {
+        self.fd
+    }
+}
+
+impl AsRawFd for OwnedFd {
+    #[inline]
+    fn as_raw_fd(&self) -> RawFd {
+        self.fd
+    }
+}
+
+impl IntoRawFd for OwnedFd {
+    #[inline]
+    fn into_raw_fd(self) -> RawFd {
+        let fd = self.fd;
+        forget(self);
+        fd
+    }
+}
+
+impl FromRawFd for OwnedFd {
+    /// Constructs a new instance of `Self` from the given raw file descriptor.
+    ///
+    /// # Safety
+    ///
+    /// The resource pointed to by `fd` must be open and suitable for assuming
+    /// ownership. The resource must not require any cleanup other than `close`.
+    #[inline]
+    unsafe fn from_raw_fd(fd: RawFd) -> Self {
+        assert_ne!(fd, -1 as RawFd);
+        // SAFETY: we just asserted that the value is in the valid range and
+        // isn't `-1` (the only value bigger than `0xFF_FF_FF_FE` unsigned)
+        unsafe { Self { fd } }
+    }
+}
+
+impl Drop for OwnedFd {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { sys::net::netc::close(self.fd) };
+    }
+}
+
+impl fmt::Debug for BorrowedFd<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BorrowedFd").field("fd", &self.fd).finish()
+    }
+}
+
+impl fmt::Debug for OwnedFd {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OwnedFd").field("fd", &self.fd).finish()
+    }
+}
+
+macro_rules! impl_is_terminal {
+    ($($t:ty),*$(,)?) => {$(
+        #[unstable(feature = "sealed", issue = "none")]
+        impl crate::sealed::Sealed for $t {}
+
+        #[stable(feature = "is_terminal", since = "1.70.0")]
+        impl crate::io::IsTerminal for $t {
+            #[inline]
+            fn is_terminal(&self) -> bool {
+                crate::sys::io::is_terminal(self)
+            }
+        }
+    )*}
+}
+
+impl_is_terminal!(BorrowedFd<'_>, OwnedFd);
+
+/// A trait to borrow the SOLID Sockets file descriptor from an underlying
+/// object.
+pub trait AsFd {
+    /// Borrows the file descriptor.
+    fn as_fd(&self) -> BorrowedFd<'_>;
+}
+
+impl<T: AsFd> AsFd for &T {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        T::as_fd(self)
+    }
+}
+
+impl<T: AsFd> AsFd for &mut T {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        T::as_fd(self)
+    }
+}
+
+impl AsFd for BorrowedFd<'_> {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        *self
+    }
+}
+
+impl AsFd for OwnedFd {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        // Safety: `OwnedFd` and `BorrowedFd` have the same validity
+        // invariants, and the `BorrowedFd` is bounded by the lifetime
+        // of `&self`.
+        unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+    }
+}
+
 /// A trait to extract the raw SOLID Sockets file descriptor from an underlying
 /// object.
 pub trait AsRawFd {

From ddfe168e6c6e6c3f8fe8c35568c84cbe11506cb9 Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 14:48:50 +0900
Subject: [PATCH 08/71] kmc-solid: Document I/O safety in `std::os::solid::io`

Mostly copied from `std::os::unix::io`, except quantifying file
descriptors with SOLID Sockets and removing the paragraph mentioning
`mmap`.
---
 library/std/src/os/solid/io.rs | 44 ++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index ab17a01e411..6bddfc779fb 100644
--- a/library/std/src/os/solid/io.rs
+++ b/library/std/src/os/solid/io.rs
@@ -1,4 +1,48 @@
 //! SOLID-specific extensions to general I/O primitives
+//!
+//! Just like raw pointers, raw SOLID Sockets file descriptors point to
+//! resources with dynamic lifetimes, and they can dangle if they outlive their
+//! resources or be forged if they're created from invalid values.
+//!
+//! This module provides three types for representing raw file descriptors
+//! with different ownership properties: raw, borrowed, and owned, which are
+//! analogous to types used for representing pointers:
+//!
+//! | Type               | Analogous to |
+//! | ------------------ | ------------ |
+//! | [`RawFd`]          | `*const _`   |
+//! | [`BorrowedFd<'a>`] | `&'a _`      |
+//! | [`OwnedFd`]        | `Box<_>`     |
+//!
+//! Like raw pointers, `RawFd` values are primitive values. And in new code,
+//! they should be considered unsafe to do I/O on (analogous to dereferencing
+//! them). Rust did not always provide this guidance, so existing code in the
+//! Rust ecosystem often doesn't mark `RawFd` usage as unsafe. Once the
+//! `io_safety` feature is stable, libraries will be encouraged to migrate,
+//! either by adding `unsafe` to APIs that dereference `RawFd` values, or by
+//! using to `BorrowedFd` or `OwnedFd` instead.
+//!
+//! Like references, `BorrowedFd` values are tied to a lifetime, to ensure
+//! that they don't outlive the resource they point to. These are safe to
+//! use. `BorrowedFd` values may be used in APIs which provide safe access to
+//! any system call except for:
+//!
+//!  - `close`, because that would end the dynamic lifetime of the resource
+//!    without ending the lifetime of the file descriptor.
+//!
+//!  - `dup2`/`dup3`, in the second argument, because this argument is
+//!    closed and assigned a new resource, which may break the assumptions
+//!    other code using that file descriptor.
+//!
+//! `BorrowedFd` values may be used in APIs which provide safe access to `dup`
+//! system calls, so types implementing `AsFd` or `From<OwnedFd>` should not
+//! assume they always have exclusive access to the underlying file
+//! description.
+//!
+//! Like boxes, `OwnedFd` values conceptually own the resource they point to,
+//! and free (close) it when they are dropped.
+//!
+//! [`BorrowedFd<'a>`]: crate::os::solid::io::BorrowedFd
 
 #![deny(unsafe_op_in_unsafe_fn)]
 #![unstable(feature = "solid_ext", issue = "none")]

From cf9c4a32f3293dc3acd2149248880d15d922c7a6 Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 16:19:58 +0900
Subject: [PATCH 09/71] kmc-solid: Implement `AsFd` and conversion to/from
 `OwnedFd` for `{TcpStream,TcpListener,UdpSocket}`

---
 library/std/src/os/solid/io.rs | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index 6bddfc779fb..67fc94830d0 100644
--- a/library/std/src/os/solid/io.rs
+++ b/library/std/src/os/solid/io.rs
@@ -245,6 +245,32 @@ impl AsFd for OwnedFd {
     }
 }
 
+macro_rules! impl_owned_fd_traits {
+    ($($t:ident)*) => {$(
+        impl AsFd for net::$t {
+            #[inline]
+            fn as_fd(&self) -> BorrowedFd<'_> {
+                unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+            }
+        }
+
+        impl From<net::$t> for OwnedFd {
+            #[inline]
+            fn from(socket: net::$t) -> OwnedFd {
+                unsafe { Self::from_raw_fd(socket.into_raw_fd()) }
+            }
+        }
+
+        impl From<OwnedFd> for net::$t {
+            #[inline]
+            fn from(owned_fd: OwnedFd) -> Self {
+                unsafe { Self::from_raw_fd(owned_fd.into_raw_fd()) }
+            }
+        }
+    )*};
+}
+impl_owned_fd_traits! { TcpStream TcpListener UdpSocket }
+
 /// A trait to extract the raw SOLID Sockets file descriptor from an underlying
 /// object.
 pub trait AsRawFd {

From 0dd3b25e2d96f953e5087d9405893ca777ebeaec Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 16:46:26 +0900
Subject: [PATCH 10/71] kmc-solid: Implement `AsFd` for `{Arc,Rc,Box}<impl
 AsFd>`

---
 library/std/src/os/solid/io.rs | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index 67fc94830d0..683edc1ca85 100644
--- a/library/std/src/os/solid/io.rs
+++ b/library/std/src/os/solid/io.rs
@@ -271,6 +271,39 @@ macro_rules! impl_owned_fd_traits {
 }
 impl_owned_fd_traits! { TcpStream TcpListener UdpSocket }
 
+/// This impl allows implementing traits that require `AsFd` on Arc.
+/// ```
+/// # #[cfg(target_os = "solid_asp3")] mod group_cfg {
+/// # use std::os::solid::io::AsFd;
+/// use std::net::UdpSocket;
+/// use std::sync::Arc;
+///
+/// trait MyTrait: AsFd {}
+/// impl MyTrait for Arc<UdpSocket> {}
+/// impl MyTrait for Box<UdpSocket> {}
+/// # }
+/// ```
+impl<T: AsFd> AsFd for crate::sync::Arc<T> {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        (**self).as_fd()
+    }
+}
+
+impl<T: AsFd> AsFd for crate::rc::Rc<T> {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        (**self).as_fd()
+    }
+}
+
+impl<T: AsFd> AsFd for Box<T> {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        (**self).as_fd()
+    }
+}
+
 /// A trait to extract the raw SOLID Sockets file descriptor from an underlying
 /// object.
 pub trait AsRawFd {

From cbfab81f3d3fe678c20ed8861fcddda98198db68 Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 19:07:18 +0900
Subject: [PATCH 11/71] kmc-solid: Replace `{From,Into}Inner<c_int>` impls with
 `*RawFd` for `Socket`

Follows how other targets are implemented.
---
 library/std/src/os/solid/io.rs   |  6 +++---
 library/std/src/sys/solid/net.rs | 30 +++++++++++++-----------------
 2 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index 683edc1ca85..54583c73af1 100644
--- a/library/std/src/os/solid/io.rs
+++ b/library/std/src/os/solid/io.rs
@@ -378,7 +378,7 @@ macro_rules! impl_as_raw_fd {
         impl AsRawFd for net::$t {
             #[inline]
             fn as_raw_fd(&self) -> RawFd {
-                *self.as_inner().socket().as_inner()
+                self.as_inner().socket().as_raw_fd()
             }
         }
     )*};
@@ -391,7 +391,7 @@ macro_rules! impl_from_raw_fd {
         impl FromRawFd for net::$t {
             #[inline]
             unsafe fn from_raw_fd(fd: RawFd) -> net::$t {
-                let socket = sys::net::Socket::from_inner(fd);
+                let socket = unsafe { sys::net::Socket::from_raw_fd(fd) };
                 net::$t::from_inner(sys_common::net::$t::from_inner(socket))
             }
         }
@@ -405,7 +405,7 @@ macro_rules! impl_into_raw_fd {
         impl IntoRawFd for net::$t {
             #[inline]
             fn into_raw_fd(self) -> RawFd {
-                self.into_inner().into_socket().into_inner()
+                self.into_inner().into_socket().into_raw_fd()
             }
         }
     )*};
diff --git a/library/std/src/sys/solid/net.rs b/library/std/src/sys/solid/net.rs
index 1eae0fc0642..4b25ca30280 100644
--- a/library/std/src/sys/solid/net.rs
+++ b/library/std/src/sys/solid/net.rs
@@ -5,9 +5,10 @@ use crate::{
     io::{self, BorrowedBuf, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut},
     mem,
     net::{Shutdown, SocketAddr},
+    os::solid::io::{AsRawFd, FromRawFd, IntoRawFd},
     ptr, str,
     sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr},
-    sys_common::{AsInner, FromInner, IntoInner},
+    sys_common::IntoInner,
     time::Duration,
 };
 
@@ -111,13 +112,6 @@ impl FileDesc {
     }
 }
 
-impl AsInner<c_int> for FileDesc {
-    #[inline]
-    fn as_inner(&self) -> &c_int {
-        &self.fd
-    }
-}
-
 impl Drop for FileDesc {
     fn drop(&mut self) {
         unsafe { netc::close(self.fd) };
@@ -454,7 +448,7 @@ impl Socket {
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
         let mut nonblocking = nonblocking as c_int;
         cvt(unsafe {
-            netc::ioctl(*self.as_inner(), netc::FIONBIO, (&mut nonblocking) as *mut c_int as _)
+            netc::ioctl(self.0.raw(), netc::FIONBIO, (&mut nonblocking) as *mut c_int as _)
         })
         .map(drop)
     }
@@ -466,25 +460,27 @@ impl Socket {
 
     // This method is used by sys_common code to abstract over targets.
     pub fn as_raw(&self) -> c_int {
-        *self.as_inner()
+        self.0.raw()
     }
 }
 
-impl AsInner<c_int> for Socket {
+impl AsRawFd for Socket {
     #[inline]
-    fn as_inner(&self) -> &c_int {
-        self.0.as_inner()
+    fn as_raw_fd(&self) -> c_int {
+        self.0.fd
     }
 }
 
-impl FromInner<c_int> for Socket {
-    fn from_inner(fd: c_int) -> Socket {
+impl FromRawFd for Socket {
+    #[inline]
+    unsafe fn from_raw_fd(fd: c_int) -> Socket {
         Socket(FileDesc::new(fd))
     }
 }
 
-impl IntoInner<c_int> for Socket {
-    fn into_inner(self) -> c_int {
+impl IntoRawFd for Socket {
+    #[inline]
+    fn into_raw_fd(self) -> c_int {
         self.0.into_raw()
     }
 }

From 6d1e4ddf0354e51e3520abfbd32a394f497d3f3b Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 8 Nov 2023 10:51:57 +0900
Subject: [PATCH 12/71] kmc-solid: Remove `FileDesc`

Removes the private type `std::sys::solid::net::FileDesc`, replacing its
only usage in `std::sys::solid::net::Socket` with `std::os::solid::io::
OwnedFd`.
---
 library/std/src/sys/solid/net.rs | 158 +++++++++----------------------
 1 file changed, 43 insertions(+), 115 deletions(-)

diff --git a/library/std/src/sys/solid/net.rs b/library/std/src/sys/solid/net.rs
index 4b25ca30280..1a7f9e347d0 100644
--- a/library/std/src/sys/solid/net.rs
+++ b/library/std/src/sys/solid/net.rs
@@ -5,7 +5,7 @@ use crate::{
     io::{self, BorrowedBuf, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut},
     mem,
     net::{Shutdown, SocketAddr},
-    os::solid::io::{AsRawFd, FromRawFd, IntoRawFd},
+    os::solid::io::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd},
     ptr, str,
     sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr},
     sys_common::IntoInner,
@@ -29,95 +29,6 @@ const fn max_iov() -> usize {
     1024
 }
 
-/// A file descriptor.
-#[rustc_layout_scalar_valid_range_start(0)]
-// libstd/os/raw/mod.rs assures me that every libstd-supported platform has a
-// 32-bit c_int. Below is -2, in two's complement, but that only works out
-// because c_int is 32 bits.
-#[rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)]
-struct FileDesc {
-    fd: c_int,
-}
-
-impl FileDesc {
-    #[inline]
-    fn new(fd: c_int) -> FileDesc {
-        assert_ne!(fd, -1i32);
-        // Safety: we just asserted that the value is in the valid range and
-        // isn't `-1` (the only value bigger than `0xFF_FF_FF_FE` unsigned)
-        unsafe { FileDesc { fd } }
-    }
-
-    #[inline]
-    fn raw(&self) -> c_int {
-        self.fd
-    }
-
-    /// Extracts the actual file descriptor without closing it.
-    #[inline]
-    fn into_raw(self) -> c_int {
-        let fd = self.fd;
-        mem::forget(self);
-        fd
-    }
-
-    fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::read(self.fd, buf.as_mut_ptr() as *mut c_void, cmp::min(buf.len(), READ_LIMIT))
-        })?;
-        Ok(ret as usize)
-    }
-
-    fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::readv(
-                self.fd,
-                bufs.as_ptr() as *const netc::iovec,
-                cmp::min(bufs.len(), max_iov()) as c_int,
-            )
-        })?;
-        Ok(ret as usize)
-    }
-
-    #[inline]
-    fn is_read_vectored(&self) -> bool {
-        true
-    }
-
-    fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::write(self.fd, buf.as_ptr() as *const c_void, cmp::min(buf.len(), READ_LIMIT))
-        })?;
-        Ok(ret as usize)
-    }
-
-    fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let ret = cvt(unsafe {
-            netc::writev(
-                self.fd,
-                bufs.as_ptr() as *const netc::iovec,
-                cmp::min(bufs.len(), max_iov()) as c_int,
-            )
-        })?;
-        Ok(ret as usize)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    fn duplicate(&self) -> io::Result<FileDesc> {
-        cvt(unsafe { netc::dup(self.fd) }).map(Self::new)
-    }
-}
-
-impl Drop for FileDesc {
-    fn drop(&mut self) {
-        unsafe { netc::close(self.fd) };
-    }
-}
-
 #[doc(hidden)]
 pub trait IsMinusOne {
     fn is_minus_one(&self) -> bool;
@@ -206,7 +117,7 @@ pub(super) fn decode_error_kind(er: abi::ER) -> ErrorKind {
 
 pub fn init() {}
 
-pub struct Socket(FileDesc);
+pub struct Socket(OwnedFd);
 
 impl Socket {
     pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
@@ -220,16 +131,13 @@ impl Socket {
     pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
         unsafe {
             let fd = cvt(netc::socket(fam, ty, 0))?;
-            let fd = FileDesc::new(fd);
-            let socket = Socket(fd);
-
-            Ok(socket)
+            Ok(Self::from_raw_fd(fd))
         }
     }
 
     pub fn connect(&self, addr: &SocketAddr) -> io::Result<()> {
         let (addr, len) = addr.into_inner();
-        cvt(unsafe { netc::connect(self.0.raw(), addr.as_ptr(), len) })?;
+        cvt(unsafe { netc::connect(self.as_raw_fd(), addr.as_ptr(), len) })?;
         Ok(())
     }
 
@@ -258,14 +166,14 @@ impl Socket {
             timeout.tv_usec = 1;
         }
 
-        let fds = netc::fd_set { num_fds: 1, fds: [self.0.raw()] };
+        let fds = netc::fd_set { num_fds: 1, fds: [self.as_raw_fd()] };
 
         let mut writefds = fds;
         let mut errorfds = fds;
 
         let n = unsafe {
             cvt(netc::select(
-                self.0.raw() + 1,
+                self.as_raw_fd() + 1,
                 ptr::null_mut(),
                 &mut writefds,
                 &mut errorfds,
@@ -288,18 +196,17 @@ impl Socket {
     }
 
     pub fn accept(&self, storage: *mut sockaddr, len: *mut socklen_t) -> io::Result<Socket> {
-        let fd = cvt_r(|| unsafe { netc::accept(self.0.raw(), storage, len) })?;
-        let fd = FileDesc::new(fd);
-        Ok(Socket(fd))
+        let fd = cvt_r(|| unsafe { netc::accept(self.as_raw_fd(), storage, len) })?;
+        unsafe { Ok(Self::from_raw_fd(fd)) }
     }
 
     pub fn duplicate(&self) -> io::Result<Socket> {
-        self.0.duplicate().map(Socket)
+        Ok(Self(self.0.try_clone()?))
     }
 
     fn recv_with_flags(&self, mut buf: BorrowedCursor<'_>, flags: c_int) -> io::Result<()> {
         let ret = cvt(unsafe {
-            netc::recv(self.0.raw(), buf.as_mut().as_mut_ptr().cast(), buf.capacity(), flags)
+            netc::recv(self.as_raw_fd(), buf.as_mut().as_mut_ptr().cast(), buf.capacity(), flags)
         })?;
         unsafe {
             buf.advance(ret as usize);
@@ -324,12 +231,19 @@ impl Socket {
     }
 
     pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.0.read_vectored(bufs)
+        let ret = cvt(unsafe {
+            netc::readv(
+                self.as_raw_fd(),
+                bufs.as_ptr() as *const netc::iovec,
+                cmp::min(bufs.len(), max_iov()) as c_int,
+            )
+        })?;
+        Ok(ret as usize)
     }
 
     #[inline]
     pub fn is_read_vectored(&self) -> bool {
-        self.0.is_read_vectored()
+        true
     }
 
     fn recv_from_with_flags(
@@ -342,7 +256,7 @@ impl Socket {
 
         let n = cvt(unsafe {
             netc::recvfrom(
-                self.0.raw(),
+                self.as_raw_fd(),
                 buf.as_mut_ptr() as *mut c_void,
                 buf.len(),
                 flags,
@@ -362,16 +276,30 @@ impl Socket {
     }
 
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        self.0.write(buf)
+        let ret = cvt(unsafe {
+            netc::write(
+                self.as_raw_fd(),
+                buf.as_ptr() as *const c_void,
+                cmp::min(buf.len(), READ_LIMIT),
+            )
+        })?;
+        Ok(ret as usize)
     }
 
     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.0.write_vectored(bufs)
+        let ret = cvt(unsafe {
+            netc::writev(
+                self.as_raw_fd(),
+                bufs.as_ptr() as *const netc::iovec,
+                cmp::min(bufs.len(), max_iov()) as c_int,
+            )
+        })?;
+        Ok(ret as usize)
     }
 
     #[inline]
     pub fn is_write_vectored(&self) -> bool {
-        self.0.is_write_vectored()
+        true
     }
 
     pub fn set_timeout(&self, dur: Option<Duration>, kind: c_int) -> io::Result<()> {
@@ -417,7 +345,7 @@ impl Socket {
             Shutdown::Read => netc::SHUT_RD,
             Shutdown::Both => netc::SHUT_RDWR,
         };
-        cvt(unsafe { netc::shutdown(self.0.raw(), how) })?;
+        cvt(unsafe { netc::shutdown(self.as_raw_fd(), how) })?;
         Ok(())
     }
 
@@ -448,7 +376,7 @@ impl Socket {
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
         let mut nonblocking = nonblocking as c_int;
         cvt(unsafe {
-            netc::ioctl(self.0.raw(), netc::FIONBIO, (&mut nonblocking) as *mut c_int as _)
+            netc::ioctl(self.as_raw_fd(), netc::FIONBIO, (&mut nonblocking) as *mut c_int as _)
         })
         .map(drop)
     }
@@ -460,27 +388,27 @@ impl Socket {
 
     // This method is used by sys_common code to abstract over targets.
     pub fn as_raw(&self) -> c_int {
-        self.0.raw()
+        self.as_raw_fd()
     }
 }
 
 impl AsRawFd for Socket {
     #[inline]
     fn as_raw_fd(&self) -> c_int {
-        self.0.fd
+        self.0.as_raw_fd()
     }
 }
 
 impl FromRawFd for Socket {
     #[inline]
     unsafe fn from_raw_fd(fd: c_int) -> Socket {
-        Socket(FileDesc::new(fd))
+        unsafe { Self(FromRawFd::from_raw_fd(fd)) }
     }
 }
 
 impl IntoRawFd for Socket {
     #[inline]
     fn into_raw_fd(self) -> c_int {
-        self.0.into_raw()
+        self.0.into_raw_fd()
     }
 }

From 46bc247bd145f3357acb07b7f146ec9514e0a193 Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 19:06:43 +0900
Subject: [PATCH 13/71] kmc-solid: Implement `{From,Into}Inner<OwnedFd>` for
 `Socket`

---
 library/std/src/sys/solid/net.rs | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/solid/net.rs b/library/std/src/sys/solid/net.rs
index 1a7f9e347d0..a768e2406c8 100644
--- a/library/std/src/sys/solid/net.rs
+++ b/library/std/src/sys/solid/net.rs
@@ -5,10 +5,10 @@ use crate::{
     io::{self, BorrowedBuf, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut},
     mem,
     net::{Shutdown, SocketAddr},
-    os::solid::io::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd},
+    os::solid::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd},
     ptr, str,
     sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr},
-    sys_common::IntoInner,
+    sys_common::{FromInner, IntoInner},
     time::Duration,
 };
 
@@ -392,6 +392,27 @@ impl Socket {
     }
 }
 
+impl FromInner<OwnedFd> for Socket {
+    #[inline]
+    fn from_inner(sock: OwnedFd) -> Socket {
+        Socket(sock)
+    }
+}
+
+impl IntoInner<OwnedFd> for Socket {
+    #[inline]
+    fn into_inner(self) -> OwnedFd {
+        self.0
+    }
+}
+
+impl AsFd for Socket {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.0.as_fd()
+    }
+}
+
 impl AsRawFd for Socket {
     #[inline]
     fn as_raw_fd(&self) -> c_int {

From c8c3339133fb25b0e059e076fb499708df39c669 Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Wed, 23 Aug 2023 18:41:26 +0900
Subject: [PATCH 14/71] kmc-solid: Reimplement `AsFd` etc for
 `{TcpStream,TcpListener,UdpSocket}` by delegating to inner `Socket`

Removes some `unsafe` blocks.
---
 library/std/src/os/solid/io.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index 54583c73af1..19b4fe22093 100644
--- a/library/std/src/os/solid/io.rs
+++ b/library/std/src/os/solid/io.rs
@@ -250,21 +250,21 @@ macro_rules! impl_owned_fd_traits {
         impl AsFd for net::$t {
             #[inline]
             fn as_fd(&self) -> BorrowedFd<'_> {
-                unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+                self.as_inner().socket().as_fd()
             }
         }
 
         impl From<net::$t> for OwnedFd {
             #[inline]
             fn from(socket: net::$t) -> OwnedFd {
-                unsafe { Self::from_raw_fd(socket.into_raw_fd()) }
+                socket.into_inner().into_socket().into_inner()
             }
         }
 
         impl From<OwnedFd> for net::$t {
             #[inline]
             fn from(owned_fd: OwnedFd) -> Self {
-                unsafe { Self::from_raw_fd(owned_fd.into_raw_fd()) }
+                Self::from_inner(FromInner::from_inner(FromInner::from_inner(owned_fd)))
             }
         }
     )*};

From 52eb92de37353737b6b9269922b7bc4c9ddddf73 Mon Sep 17 00:00:00 2001
From: Tomoaki Kawada <kawada@kmckk.co.jp>
Date: Thu, 24 Aug 2023 11:33:08 +0900
Subject: [PATCH 15/71] kmc-solid: Re-export `{As,Borrowed,Owned}Fd` in
 `std::os::solid::prelude`

---
 library/std/src/os/solid/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/os/solid/mod.rs b/library/std/src/os/solid/mod.rs
index 4328ba7c340..0bb83c73ddf 100644
--- a/library/std/src/os/solid/mod.rs
+++ b/library/std/src/os/solid/mod.rs
@@ -13,5 +13,5 @@ pub mod prelude {
     pub use super::ffi::{OsStrExt, OsStringExt};
     #[doc(no_inline)]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub use super::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+    pub use super::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 }

From d585eecb053b79ad2ef7034b8283bb684a3dfe5b Mon Sep 17 00:00:00 2001
From: okaneco <47607823+okaneco@users.noreply.github.com>
Date: Wed, 8 Nov 2023 14:44:13 -0500
Subject: [PATCH 16/71] Refactor `binary_search_by` to use conditional moves

Refactor the if/else checking on cmp::Ordering variants to a
"branchless" reassignment of left and right. This change results
in fewer branches and instructions.
---
 library/core/src/slice/mod.rs | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 45080eda2ce..9075a3bb8e8 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -6,7 +6,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::cmp::Ordering::{self, Greater, Less};
+use crate::cmp::Ordering::{self, Equal, Greater, Less};
 use crate::fmt;
 use crate::intrinsics::{assert_unsafe_precondition, exact_div};
 use crate::marker::Copy;
@@ -2844,14 +2844,13 @@ impl<T> [T] {
             // we have `left + size/2 < self.len()`, and this is in-bounds.
             let cmp = f(unsafe { self.get_unchecked(mid) });
 
-            // The reason why we use if/else control flow rather than match
-            // is because match reorders comparison operations, which is perf sensitive.
-            // This is x86 asm for u8: https://rust.godbolt.org/z/8Y8Pra.
-            if cmp == Less {
-                left = mid + 1;
-            } else if cmp == Greater {
-                right = mid;
-            } else {
+            // This control flow produces conditional moves, which results in
+            // fewer branches and instructions than if/else or matching on
+            // cmp::Ordering.
+            // This is x86 asm for u8: https://rust.godbolt.org/z/698eYffTx.
+            left = if cmp == Less { mid + 1 } else { left };
+            right = if cmp == Greater { mid } else { right };
+            if cmp == Equal {
                 // SAFETY: same as the `get_unchecked` above
                 unsafe { crate::intrinsics::assume(mid < self.len()) };
                 return Ok(mid);

From 056d4e4c51dce1fddb1773e5a523525b8fd24d65 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 11 Nov 2023 16:20:06 +0300
Subject: [PATCH 17/71] print the change warnings once for per id

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/bin/main.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/bootstrap/src/bin/main.rs b/src/bootstrap/src/bin/main.rs
index 0a6072ae1a5..1cbe3991abf 100644
--- a/src/bootstrap/src/bin/main.rs
+++ b/src/bootstrap/src/bin/main.rs
@@ -109,11 +109,19 @@ fn check_version(config: &Config) -> Option<String> {
     }
 
     let latest_config_id = CONFIG_CHANGE_HISTORY.last().unwrap();
+    let warned_id_path = config.out.join("bootstrap").join(".last-warned-change-id");
+
     if let Some(id) = config.change_id {
         if &id == latest_config_id {
             return None;
         }
 
+        if let Ok(last_warned_id) = fs::read_to_string(&warned_id_path) {
+            if id.to_string() == last_warned_id {
+                return None;
+            }
+        }
+
         let change_links: Vec<String> = find_recent_config_change_ids(id)
             .iter()
             .map(|id| format!("https://github.com/rust-lang/rust/pull/{id}"))
@@ -132,6 +140,8 @@ fn check_version(config: &Config) -> Option<String> {
             msg.push_str(&format!(
                 "update `config.toml` to use `change-id = {latest_config_id}` instead"
             ));
+
+            t!(fs::write(warned_id_path, id.to_string()));
         }
     } else {
         msg.push_str("WARNING: The `change-id` is missing in the `config.toml`. This means that you will not be able to track the major changes made to the bootstrap configurations.\n");

From 12ab8c638fefb182e24ccfe05924ae35eb1926a2 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 11 Nov 2023 18:01:40 +0300
Subject: [PATCH 18/71] refactor change-tracking implementation

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/bin/main.rs               | 29 +++++----
 src/bootstrap/src/core/build_steps/setup.rs |  2 +-
 src/bootstrap/src/lib.rs                    | 66 +++++++++++++++++----
 3 files changed, 70 insertions(+), 27 deletions(-)

diff --git a/src/bootstrap/src/bin/main.rs b/src/bootstrap/src/bin/main.rs
index 1cbe3991abf..eb3fa0783a1 100644
--- a/src/bootstrap/src/bin/main.rs
+++ b/src/bootstrap/src/bin/main.rs
@@ -108,11 +108,11 @@ fn check_version(config: &Config) -> Option<String> {
         msg.push_str("WARNING: The use of `changelog-seen` is deprecated. Please refer to `change-id` option in `config.example.toml` instead.\n");
     }
 
-    let latest_config_id = CONFIG_CHANGE_HISTORY.last().unwrap();
+    let latest_change_id = CONFIG_CHANGE_HISTORY.last().unwrap().change_id;
     let warned_id_path = config.out.join("bootstrap").join(".last-warned-change-id");
 
     if let Some(id) = config.change_id {
-        if &id == latest_config_id {
+        if id == latest_change_id {
             return None;
         }
 
@@ -122,23 +122,22 @@ fn check_version(config: &Config) -> Option<String> {
             }
         }
 
-        let change_links: Vec<String> = find_recent_config_change_ids(id)
-            .iter()
-            .map(|id| format!("https://github.com/rust-lang/rust/pull/{id}"))
-            .collect();
-        if !change_links.is_empty() {
-            msg.push_str("WARNING: there have been changes to x.py since you last updated.\n");
-            msg.push_str("To see more detail about these changes, visit the following PRs:\n");
+        let changes = find_recent_config_change_ids(id);
 
-            for link in change_links {
-                msg.push_str(&format!("  - {link}\n"));
+        if !changes.is_empty() {
+            msg.push_str("There have been changes to x.py since you last updated:\n");
+
+            for change in changes {
+                msg.push_str(&format!("  [{}] {}\n", change.severity.to_string(), change.summary));
+                msg.push_str(&format!(
+                    "    - PR Link https://github.com/rust-lang/rust/pull/{}\n",
+                    change.change_id
+                ));
             }
 
-            msg.push_str("WARNING: there have been changes to x.py since you last updated.\n");
-
             msg.push_str("NOTE: to silence this warning, ");
             msg.push_str(&format!(
-                "update `config.toml` to use `change-id = {latest_config_id}` instead"
+                "update `config.toml` to use `change-id = {latest_change_id}` instead"
             ));
 
             t!(fs::write(warned_id_path, id.to_string()));
@@ -146,7 +145,7 @@ fn check_version(config: &Config) -> Option<String> {
     } else {
         msg.push_str("WARNING: The `change-id` is missing in the `config.toml`. This means that you will not be able to track the major changes made to the bootstrap configurations.\n");
         msg.push_str("NOTE: to silence this warning, ");
-        msg.push_str(&format!("add `change-id = {latest_config_id}` at the top of `config.toml`"));
+        msg.push_str(&format!("add `change-id = {latest_change_id}` at the top of `config.toml`"));
     };
 
     Some(msg)
diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index 486a1e20f18..bbbdb4c3186 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -226,7 +226,7 @@ fn setup_config_toml(path: &PathBuf, profile: Profile, config: &Config) {
         return;
     }
 
-    let latest_change_id = CONFIG_CHANGE_HISTORY.last().unwrap();
+    let latest_change_id = CONFIG_CHANGE_HISTORY.last().unwrap().change_id;
     let settings = format!(
         "# Includes one of the default files in src/bootstrap/defaults\n\
     profile = \"{profile}\"\n\
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 33b8f1a7ce7..0351ec53824 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -69,16 +69,59 @@ const LLVM_TOOLS: &[&str] = &[
 /// LLD file names for all flavors.
 const LLD_FILE_NAMES: &[&str] = &["ld.lld", "ld64.lld", "lld-link", "wasm-ld"];
 
+#[derive(Clone, Debug)]
+pub struct ChangeInfo {
+    /// Represents the ID of PR caused major change on bootstrap.
+    pub change_id: usize,
+    pub severity: ChangeSeverity,
+    /// Provides a short summary of the change that will guide developers
+    /// on "how to handle/behave" in response to the changes.
+    pub summary: &'static str,
+}
+
+#[derive(Clone, Debug)]
+pub enum ChangeSeverity {
+    Info,
+    Warning,
+}
+
+impl ToString for ChangeSeverity {
+    fn to_string(&self) -> String {
+        match self {
+            ChangeSeverity::Info => "INFO".to_string(),
+            ChangeSeverity::Warning => "WARNING".to_string(),
+        }
+    }
+}
+
 /// Keeps track of major changes made to the bootstrap configuration.
 ///
-/// These values also represent the IDs of the PRs that caused major changes.
-/// You can visit `https://github.com/rust-lang/rust/pull/{any-id-from-the-list}` to
-/// check for more details regarding each change.
 ///
 /// If you make any major changes (such as adding new values or changing default values),
-/// please ensure that the associated PR ID is added to the end of this list.
-/// This is necessary because the list must be sorted by the merge date.
-pub const CONFIG_CHANGE_HISTORY: &[usize] = &[115898, 116998, 117435, 116881];
+/// please ensure adding `ChangeInfo` to the end(because the list must be sorted by the merge date)
+/// of this list.
+pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
+    ChangeInfo {
+        change_id: 115898,
+        severity: ChangeSeverity::Info,
+        summary: "Implementation of this change-tracking system. Ignore this.",
+    },
+    ChangeInfo {
+        change_id: 116998,
+        severity: ChangeSeverity::Info,
+        summary: "Removed android-ndk r15 support in favor of android-ndk r25b.",
+    },
+    ChangeInfo {
+        change_id: 117435,
+        severity: ChangeSeverity::Info,
+        summary: "New option `rust.parallel-compiler` added to config.toml.",
+    },
+    ChangeInfo {
+        change_id: 116881,
+        severity: ChangeSeverity::Warning,
+        summary: "Default value of `download-ci-llvm` was changed for `codegen` profile.",
+    },
+];
 
 /// Extra --check-cfg to add when building
 /// (Mode restriction, config name, config values (if any))
@@ -1849,14 +1892,14 @@ fn envify(s: &str) -> String {
         .collect()
 }
 
-pub fn find_recent_config_change_ids(current_id: usize) -> Vec<usize> {
-    if !CONFIG_CHANGE_HISTORY.contains(&current_id) {
+pub fn find_recent_config_change_ids(current_id: usize) -> Vec<ChangeInfo> {
+    if !CONFIG_CHANGE_HISTORY.iter().any(|config| config.change_id == current_id) {
         // If the current change-id is greater than the most recent one, return
         // an empty list (it may be due to switching from a recent branch to an
         // older one); otherwise, return the full list (assuming the user provided
         // the incorrect change-id by accident).
-        if let Some(max_id) = CONFIG_CHANGE_HISTORY.iter().max() {
-            if &current_id > max_id {
+        if let Some(config) = CONFIG_CHANGE_HISTORY.iter().max_by_key(|config| config.change_id) {
+            if &current_id > &config.change_id {
                 return Vec::new();
             }
         }
@@ -1864,7 +1907,8 @@ pub fn find_recent_config_change_ids(current_id: usize) -> Vec<usize> {
         return CONFIG_CHANGE_HISTORY.to_vec();
     }
 
-    let index = CONFIG_CHANGE_HISTORY.iter().position(|&id| id == current_id).unwrap();
+    let index =
+        CONFIG_CHANGE_HISTORY.iter().position(|config| config.change_id == current_id).unwrap();
 
     CONFIG_CHANGE_HISTORY
         .iter()

From d3d3eb91f72690a3d8a417c7dabe500a6256daf1 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 11 Nov 2023 18:11:02 +0300
Subject: [PATCH 19/71] remove .last-warned-change-id on `x clean`

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/build_steps/clean.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/bootstrap/src/core/build_steps/clean.rs b/src/bootstrap/src/core/build_steps/clean.rs
index cbb6b5f4648..a3fb330ddfb 100644
--- a/src/bootstrap/src/core/build_steps/clean.rs
+++ b/src/bootstrap/src/core/build_steps/clean.rs
@@ -145,6 +145,7 @@ fn clean_specific_stage(build: &Build, stage: u32) {
 fn clean_default(build: &Build) {
     rm_rf(&build.out.join("tmp"));
     rm_rf(&build.out.join("dist"));
+    rm_rf(&build.out.join("bootstrap").join(".last-warned-change-id"));
     rm_rf(&build.out.join("rustfmt.stamp"));
 
     for host in &build.hosts {

From 06f6cd95beca124a54a7346ea2e31b75e1bcfc5a Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 12 Nov 2023 13:26:04 +0300
Subject: [PATCH 20/71] bootstrap: add doc-comments for `ChangeSeverity`

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/lib.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 0351ec53824..00fe4422e5c 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -81,7 +81,10 @@ pub struct ChangeInfo {
 
 #[derive(Clone, Debug)]
 pub enum ChangeSeverity {
+    /// Used when build configurations continue working as before.
     Info,
+    /// Used when the default value of an option changes, or support for an option is removed entirely,
+    /// potentially requiring developers to update their build configurations.
     Warning,
 }
 
@@ -96,7 +99,6 @@ impl ToString for ChangeSeverity {
 
 /// Keeps track of major changes made to the bootstrap configuration.
 ///
-///
 /// If you make any major changes (such as adding new values or changing default values),
 /// please ensure adding `ChangeInfo` to the end(because the list must be sorted by the merge date)
 /// of this list.

From 9a6afd0362acee1ee9685f50e6c5286a19baf6d9 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 11 Nov 2023 21:29:32 +0300
Subject: [PATCH 21/71] write .last-warned-change-id only if environment is tty

As the .last-warned-change-id is only used for change tracking,
we don't need to generate/write it outside of the tty.
Otherwise, rust-analyzer could create this file, and developers
wouldn't be able to see the bootstrap change alerts, assuming
that they have already seen them.

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/bin/main.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/bin/main.rs b/src/bootstrap/src/bin/main.rs
index eb3fa0783a1..35010bea818 100644
--- a/src/bootstrap/src/bin/main.rs
+++ b/src/bootstrap/src/bin/main.rs
@@ -9,7 +9,10 @@
 use std::io::Write;
 #[cfg(all(any(unix, windows), not(target_os = "solaris")))]
 use std::process;
-use std::{env, fs};
+use std::{
+    env, fs,
+    io::{self, IsTerminal},
+};
 
 #[cfg(all(any(unix, windows), not(target_os = "solaris")))]
 use bootstrap::t;
@@ -140,7 +143,9 @@ fn check_version(config: &Config) -> Option<String> {
                 "update `config.toml` to use `change-id = {latest_change_id}` instead"
             ));
 
-            t!(fs::write(warned_id_path, id.to_string()));
+            if io::stdout().is_terminal() {
+                t!(fs::write(warned_id_path, id.to_string()));
+            }
         }
     } else {
         msg.push_str("WARNING: The `change-id` is missing in the `config.toml`. This means that you will not be able to track the major changes made to the bootstrap configurations.\n");

From a355df44320f516547cd1e715ff9ea694256c978 Mon Sep 17 00:00:00 2001
From: zhiqiangxu <652732310@qq.com>
Date: Thu, 16 Nov 2023 00:01:57 +0800
Subject: [PATCH 22/71] remove unnecessary drop

---
 library/core/src/cell.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 0978b3c9280..f10a82c5694 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -409,8 +409,7 @@ impl<T> Cell<T> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn set(&self, val: T) {
-        let old = self.replace(val);
-        drop(old);
+        self.replace(val);
     }
 
     /// Swaps the values of two `Cell`s.

From df58704701569ec53de043eb5ebf34248f78c1ac Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Tue, 7 Nov 2023 05:42:46 +0000
Subject: [PATCH 23/71] Define `INVALID_HANDLE_VALUE` ourselves

---
 library/std/src/sys/windows/c.rs              | 2 ++
 library/std/src/sys/windows/c/windows_sys.lst | 2 +-
 library/std/src/sys/windows/c/windows_sys.rs  | 1 -
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/windows/c.rs b/library/std/src/sys/windows/c.rs
index a349e24b039..795e1c16041 100644
--- a/library/std/src/sys/windows/c.rs
+++ b/library/std/src/sys/windows/c.rs
@@ -46,6 +46,8 @@ pub use FD_SET as fd_set;
 pub use LINGER as linger;
 pub use TIMEVAL as timeval;
 
+pub const INVALID_HANDLE_VALUE: HANDLE = ::core::ptr::invalid_mut(-1i32 as _);
+
 // https://learn.microsoft.com/en-us/cpp/c-runtime-library/exit-success-exit-failure?view=msvc-170
 pub const EXIT_SUCCESS: u32 = 0;
 pub const EXIT_FAILURE: u32 = 1;
diff --git a/library/std/src/sys/windows/c/windows_sys.lst b/library/std/src/sys/windows/c/windows_sys.lst
index 38bf15b7c72..5cd738c2930 100644
--- a/library/std/src/sys/windows/c/windows_sys.lst
+++ b/library/std/src/sys/windows/c/windows_sys.lst
@@ -2,6 +2,7 @@
 --config flatten std
 --filter
 // tidy-alphabetical-start
+!Windows.Win32.Foundation.INVALID_HANDLE_VALUE
 Windows.Wdk.Storage.FileSystem.FILE_COMPLETE_IF_OPLOCKED
 Windows.Wdk.Storage.FileSystem.FILE_CONTAINS_EXTENDED_CREATE_INFORMATION
 Windows.Wdk.Storage.FileSystem.FILE_CREATE
@@ -1923,7 +1924,6 @@ Windows.Win32.Foundation.HANDLE_FLAG_INHERIT
 Windows.Win32.Foundation.HANDLE_FLAG_PROTECT_FROM_CLOSE
 Windows.Win32.Foundation.HANDLE_FLAGS
 Windows.Win32.Foundation.HMODULE
-Windows.Win32.Foundation.INVALID_HANDLE_VALUE
 Windows.Win32.Foundation.MAX_PATH
 Windows.Win32.Foundation.NO_ERROR
 Windows.Win32.Foundation.NTSTATUS
diff --git a/library/std/src/sys/windows/c/windows_sys.rs b/library/std/src/sys/windows/c/windows_sys.rs
index e0509e6a5dd..221dc2346a8 100644
--- a/library/std/src/sys/windows/c/windows_sys.rs
+++ b/library/std/src/sys/windows/c/windows_sys.rs
@@ -3498,7 +3498,6 @@ impl ::core::clone::Clone for INIT_ONCE {
 }
 pub const INIT_ONCE_INIT_FAILED: u32 = 4u32;
 pub const INVALID_FILE_ATTRIBUTES: u32 = 4294967295u32;
-pub const INVALID_HANDLE_VALUE: HANDLE = ::core::ptr::invalid_mut(-1i32 as _);
 pub const INVALID_SOCKET: SOCKET = -1i32 as _;
 #[repr(C)]
 pub struct IN_ADDR {

From 00a12af3ca17746f3e4548d783b7107f42155101 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Fri, 17 Nov 2023 12:13:38 +0000
Subject: [PATCH 24/71] Update windows-bindgen

---
 Cargo.lock                                    | 8 ++++----
 library/std/src/sys/windows/c/windows_sys.lst | 2 +-
 library/std/src/sys/windows/c/windows_sys.rs  | 8 ++++----
 src/tools/generate-windows-sys/Cargo.toml     | 2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 92bac995bc6..52640036f9e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6130,9 +6130,9 @@ dependencies = [
 
 [[package]]
 name = "windows-bindgen"
-version = "0.51.1"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc1f16b778125675feee0d15d6dd9f6af0e3ac52b3233d63a10aa39230c1cd75"
+checksum = "970efb0b6849eb8a87a898f586af7cc167567b070014c7434514c0bde0ca341c"
 dependencies = [
  "proc-macro2",
  "rayon",
@@ -6142,9 +6142,9 @@ dependencies = [
 
 [[package]]
 name = "windows-metadata"
-version = "0.51.1"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "753135d996f9da437c0b31dbde3032489a61708361929bcc07d4fba0b161000e"
+checksum = "218fd59201e26acdbb894fa2b302d1de84bf3eec7d0eb894ac8e9c5a854ee4ef"
 
 [[package]]
 name = "windows-sys"
diff --git a/library/std/src/sys/windows/c/windows_sys.lst b/library/std/src/sys/windows/c/windows_sys.lst
index 5cd738c2930..f91e1054a04 100644
--- a/library/std/src/sys/windows/c/windows_sys.lst
+++ b/library/std/src/sys/windows/c/windows_sys.lst
@@ -2483,7 +2483,6 @@ Windows.Win32.System.SystemInformation.GetSystemTimeAsFileTime
 Windows.Win32.System.SystemInformation.GetWindowsDirectoryW
 Windows.Win32.System.SystemInformation.PROCESSOR_ARCHITECTURE
 Windows.Win32.System.SystemInformation.SYSTEM_INFO
-Windows.Win32.System.SystemServices.ALL_PROCESSOR_GROUPS
 Windows.Win32.System.SystemServices.DLL_PROCESS_DETACH
 Windows.Win32.System.SystemServices.DLL_THREAD_DETACH
 Windows.Win32.System.SystemServices.EXCEPTION_MAXIMUM_PARAMETERS
@@ -2492,6 +2491,7 @@ Windows.Win32.System.SystemServices.IO_REPARSE_TAG_SYMLINK
 Windows.Win32.System.Threading.ABOVE_NORMAL_PRIORITY_CLASS
 Windows.Win32.System.Threading.AcquireSRWLockExclusive
 Windows.Win32.System.Threading.AcquireSRWLockShared
+Windows.Win32.System.Threading.ALL_PROCESSOR_GROUPS
 Windows.Win32.System.Threading.BELOW_NORMAL_PRIORITY_CLASS
 Windows.Win32.System.Threading.CREATE_BREAKAWAY_FROM_JOB
 Windows.Win32.System.Threading.CREATE_DEFAULT_ERROR_MODE
diff --git a/library/std/src/sys/windows/c/windows_sys.rs b/library/std/src/sys/windows/c/windows_sys.rs
index 221dc2346a8..b38b70c8983 100644
--- a/library/std/src/sys/windows/c/windows_sys.rs
+++ b/library/std/src/sys/windows/c/windows_sys.rs
@@ -4,7 +4,7 @@
 // regenerate the bindings.
 //
 // ignore-tidy-filelength
-// Bindings generated by `windows-bindgen` 0.51.1
+// Bindings generated by `windows-bindgen` 0.52.0
 
 #![allow(non_snake_case, non_upper_case_globals, non_camel_case_types, dead_code, clippy::all)]
 #[link(name = "advapi32")]
@@ -63,7 +63,7 @@ extern "system" {
         lpnewfilename: PCWSTR,
         lpprogressroutine: LPPROGRESS_ROUTINE,
         lpdata: *const ::core::ffi::c_void,
-        pbcancel: *mut i32,
+        pbcancel: *mut BOOL,
         dwcopyflags: u32,
     ) -> BOOL;
 }
@@ -619,7 +619,7 @@ extern "system" {
         lpmultibytestr: PSTR,
         cbmultibyte: i32,
         lpdefaultchar: PCSTR,
-        lpuseddefaultchar: *mut i32,
+        lpuseddefaultchar: *mut BOOL,
     ) -> i32;
 }
 #[link(name = "kernel32")]
@@ -869,7 +869,7 @@ pub const AF_INET: ADDRESS_FAMILY = 2u16;
 pub const AF_INET6: ADDRESS_FAMILY = 23u16;
 pub const AF_UNIX: u16 = 1u16;
 pub const AF_UNSPEC: ADDRESS_FAMILY = 0u16;
-pub const ALL_PROCESSOR_GROUPS: u32 = 65535u32;
+pub const ALL_PROCESSOR_GROUPS: u16 = 65535u16;
 #[repr(C)]
 pub union ARM64_NT_NEON128 {
     pub Anonymous: ARM64_NT_NEON128_0,
diff --git a/src/tools/generate-windows-sys/Cargo.toml b/src/tools/generate-windows-sys/Cargo.toml
index 9821677a122..d8a7a06efc6 100644
--- a/src/tools/generate-windows-sys/Cargo.toml
+++ b/src/tools/generate-windows-sys/Cargo.toml
@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies.windows-bindgen]
-version = "0.51.1"
+version = "0.52.0"

From db629211591f7ac8ab6d502d8bee3fce8b528312 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Fri, 17 Nov 2023 19:54:37 -0500
Subject: [PATCH 25/71] Document behavior of `<dyn Any as Any>::type_id()`

See also #57893
---
 library/core/src/any.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index 8f5404d9713..22777fb078a 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -115,6 +115,11 @@ use crate::intrinsics;
 pub trait Any: 'static {
     /// Gets the `TypeId` of `self`.
     ///
+    /// If called on a `dyn Any` trait object
+    /// (or a trait object of a subtrait of `Any`),
+    /// this returns the `TypeId` of the underlying
+    /// concrete type, not that of `dyn Any` itself.
+    ///
     /// # Examples
     ///
     /// ```

From e5038f3e2ac641947049bdb893657e427dc1b6e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Sun, 12 Nov 2023 10:48:29 +0100
Subject: [PATCH 26/71] Unify passing of flags to rustdoc

---
 src/bootstrap/src/bin/rustdoc.rs           | 10 ----------
 src/bootstrap/src/core/build_steps/test.rs | 13 +++----------
 src/bootstrap/src/core/builder.rs          |  8 ++++----
 src/bootstrap/src/utils/helpers.rs         | 19 +++++++++++++++++++
 4 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/src/bootstrap/src/bin/rustdoc.rs b/src/bootstrap/src/bin/rustdoc.rs
index dbbce6fe220..d32c3e78d5e 100644
--- a/src/bootstrap/src/bin/rustdoc.rs
+++ b/src/bootstrap/src/bin/rustdoc.rs
@@ -3,7 +3,6 @@
 //! See comments in `src/bootstrap/rustc.rs` for more information.
 
 use std::env;
-use std::ffi::OsString;
 use std::path::PathBuf;
 use std::process::Command;
 
@@ -52,15 +51,6 @@ fn main() {
     if env::var_os("RUSTC_FORCE_UNSTABLE").is_some() {
         cmd.arg("-Z").arg("force-unstable-if-unmarked");
     }
-    if let Some(linker) = env::var_os("RUSTDOC_LINKER") {
-        let mut arg = OsString::from("-Clinker=");
-        arg.push(&linker);
-        cmd.arg(arg);
-    }
-    if let Ok(no_threads) = env::var("RUSTDOC_LLD_NO_THREADS") {
-        cmd.arg("-Clink-arg=-fuse-ld=lld");
-        cmd.arg(format!("-Clink-arg=-Wl,{no_threads}"));
-    }
     // Cargo doesn't pass RUSTDOCFLAGS to proc_macros:
     // https://github.com/rust-lang/cargo/issues/4423
     // Thus, if we are on stage 0, we explicitly set `--cfg=bootstrap`.
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index d2aa89dee28..dc9b56f30db 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -29,7 +29,7 @@ use crate::utils;
 use crate::utils::cache::{Interned, INTERNER};
 use crate::utils::exec::BootstrapCommand;
 use crate::utils::helpers::{
-    self, add_link_lib_path, dylib_path, dylib_path_var, output, t,
+    self, add_link_lib_path, add_rustdoc_lld_flags, dylib_path, dylib_path_var, output, t,
     target_supports_cranelift_backend, up_to_date,
 };
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
@@ -862,15 +862,8 @@ impl Step for RustdocTheme {
             .env("CFG_RELEASE_CHANNEL", &builder.config.channel)
             .env("RUSTDOC_REAL", builder.rustdoc(self.compiler))
             .env("RUSTC_BOOTSTRAP", "1");
-        if let Some(linker) = builder.linker(self.compiler.host) {
-            cmd.env("RUSTDOC_LINKER", linker);
-        }
-        if builder.is_fuse_ld_lld(self.compiler.host) {
-            cmd.env(
-                "RUSTDOC_LLD_NO_THREADS",
-                helpers::lld_flag_no_threads(self.compiler.host.contains("windows")),
-            );
-        }
+        add_rustdoc_lld_flags(&mut cmd, builder, self.compiler.host, true);
+
         builder.run_delaying_failure(&mut cmd);
     }
 }
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index cd276674dee..301d3dfe299 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -18,7 +18,9 @@ use crate::core::build_steps::{check, clean, compile, dist, doc, install, run, s
 use crate::core::config::flags::{Color, Subcommand};
 use crate::core::config::{DryRun, SplitDebuginfo, TargetSelection};
 use crate::utils::cache::{Cache, Interned, INTERNER};
-use crate::utils::helpers::{self, add_dylib_path, add_link_lib_path, exe, libdir, output, t};
+use crate::utils::helpers::{
+    self, add_dylib_path, add_link_lib_path, add_rustdoc_lld_flags, exe, libdir, output, t,
+};
 use crate::Crate;
 use crate::EXTRA_CHECK_CFGS;
 use crate::{Build, CLang, DocTests, GitRepo, Mode};
@@ -1173,9 +1175,7 @@ impl<'a> Builder<'a> {
         cmd.env_remove("MAKEFLAGS");
         cmd.env_remove("MFLAGS");
 
-        if let Some(linker) = self.linker(compiler.host) {
-            cmd.env("RUSTDOC_LINKER", linker);
-        }
+        add_rustdoc_lld_flags(&mut cmd, self, compiler.host, false);
         cmd
     }
 
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index 5bc81f2d983..c53cc626b97 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -470,3 +470,22 @@ pub fn extract_beta_rev(version: &str) -> Option<String> {
 
     count
 }
+
+pub fn add_rustdoc_lld_flags(
+    cmd: &mut Command,
+    builder: &Builder<'_>,
+    target: TargetSelection,
+    single_threaded: bool,
+) {
+    if let Some(linker) = builder.linker(target) {
+        let mut flag = std::ffi::OsString::from("-Clinker=");
+        flag.push(linker);
+        cmd.arg(flag);
+    }
+    if builder.is_fuse_ld_lld(target) {
+        cmd.arg("-Clink-arg=-fuse-ld=lld");
+        if single_threaded {
+            cmd.arg(format!("-Clink-arg=-Wl,{}", lld_flag_no_threads(target.contains("windows"))));
+        }
+    }
+}

From 3a486c1feb0a4846a3bcff0dda5182dc9c762ba2 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Sun, 19 Nov 2023 16:24:39 +0000
Subject: [PATCH 27/71] Use an absolute path to the NUL device

While a bare "NUL" *should* be redirected to the NUL device, especially in this simple case, let's be explicit that we aren't opening a file called "NUL" and instead open it directly.

This will also set a good example for people copying std code.
---
 library/std/src/sys/windows/process.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/windows/process.rs b/library/std/src/sys/windows/process.rs
index f4078d35944..3b22f6d2e31 100644
--- a/library/std/src/sys/windows/process.rs
+++ b/library/std/src/sys/windows/process.rs
@@ -597,7 +597,7 @@ impl Stdio {
                 opts.read(stdio_id == c::STD_INPUT_HANDLE);
                 opts.write(stdio_id != c::STD_INPUT_HANDLE);
                 opts.security_attributes(&mut sa);
-                File::open(Path::new("NUL"), &opts).map(|file| file.into_inner())
+                File::open(Path::new(r"\\.\NUL"), &opts).map(|file| file.into_inner())
             }
         }
     }

From 0f466b06d197729ebeeb72a9503f0a878749ec87 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 20 Nov 2023 11:50:18 -0700
Subject: [PATCH 28/71] rustdoc: rename `issue-\d+.rs` tests to have meaningful
 names

---
 .../rustdoc/{issue-38129.rs => doctest-crate-attributes-38129.rs} | 0
 tests/rustdoc/{issue-43153.rs => doctest-include-43153.rs}        | 0
 tests/rustdoc/{issue-38219.rs => doctest-macro-38219.rs}          | 0
 ...issue-48377.rs => doctest-markdown-trailing-docblock-48377.rs} | 0
 tests/rustdoc/{issue-46767.rs => enum-variant-private-46767.rs}   | 0
 tests/rustdoc/{issue-46766.rs => enum-variant-reexport-46766.rs}  | 0
 .../rustdoc/{issue-43701.rs => foreign-implementors-js-43701.rs}  | 0
 tests/rustdoc/{issue-34423.rs => ice-34423.rs}                    | 0
 tests/rustdoc/{issue-36031.rs => ice-36031.rs}                    | 0
 tests/rustdoc/{issue-46976.rs => ice-apit-46976.rs}               | 0
 .../{issue-48414.rs => ice-circular-intra-doc-link-48414.rs}      | 0
 tests/rustdoc/{issue-40936.rs => ice-extern-crate-40936.rs}       | 0
 .../rustdoc/{issue-46271.rs => ice-nested-extern-crate-46271.rs}  | 0
 tests/rustdoc/{issue-47639.rs => ice-nested-macro-rules-47639.rs} | 0
 tests/rustdoc/{issue-34473.rs => inline-rename-34473.rs}          | 0
 tests/rustdoc/{issue-47038.rs => private-use-decl-macro-47038.rs} | 0
 ...t-of-pub-reexport.rs => pub-reexport-of-pub-reexport-46506.rs} | 0
 tests/rustdoc/{issue-43893.rs => src-links-implementor-43893.rs}  | 0
 ...sue-45584.rs => trait-implementations-duplicate-self-45584.rs} | 0
 tests/rustdoc/{issue-34928.rs => tuple-struct-34928.rs}           | 0
 20 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/rustdoc/{issue-38129.rs => doctest-crate-attributes-38129.rs} (100%)
 rename tests/rustdoc/{issue-43153.rs => doctest-include-43153.rs} (100%)
 rename tests/rustdoc/{issue-38219.rs => doctest-macro-38219.rs} (100%)
 rename tests/rustdoc/{issue-48377.rs => doctest-markdown-trailing-docblock-48377.rs} (100%)
 rename tests/rustdoc/{issue-46767.rs => enum-variant-private-46767.rs} (100%)
 rename tests/rustdoc/{issue-46766.rs => enum-variant-reexport-46766.rs} (100%)
 rename tests/rustdoc/{issue-43701.rs => foreign-implementors-js-43701.rs} (100%)
 rename tests/rustdoc/{issue-34423.rs => ice-34423.rs} (100%)
 rename tests/rustdoc/{issue-36031.rs => ice-36031.rs} (100%)
 rename tests/rustdoc/{issue-46976.rs => ice-apit-46976.rs} (100%)
 rename tests/rustdoc/{issue-48414.rs => ice-circular-intra-doc-link-48414.rs} (100%)
 rename tests/rustdoc/{issue-40936.rs => ice-extern-crate-40936.rs} (100%)
 rename tests/rustdoc/{issue-46271.rs => ice-nested-extern-crate-46271.rs} (100%)
 rename tests/rustdoc/{issue-47639.rs => ice-nested-macro-rules-47639.rs} (100%)
 rename tests/rustdoc/{issue-34473.rs => inline-rename-34473.rs} (100%)
 rename tests/rustdoc/{issue-47038.rs => private-use-decl-macro-47038.rs} (100%)
 rename tests/rustdoc/{issue-46506-pub-reexport-of-pub-reexport.rs => pub-reexport-of-pub-reexport-46506.rs} (100%)
 rename tests/rustdoc/{issue-43893.rs => src-links-implementor-43893.rs} (100%)
 rename tests/rustdoc/{issue-45584.rs => trait-implementations-duplicate-self-45584.rs} (100%)
 rename tests/rustdoc/{issue-34928.rs => tuple-struct-34928.rs} (100%)

diff --git a/tests/rustdoc/issue-38129.rs b/tests/rustdoc/doctest-crate-attributes-38129.rs
similarity index 100%
rename from tests/rustdoc/issue-38129.rs
rename to tests/rustdoc/doctest-crate-attributes-38129.rs
diff --git a/tests/rustdoc/issue-43153.rs b/tests/rustdoc/doctest-include-43153.rs
similarity index 100%
rename from tests/rustdoc/issue-43153.rs
rename to tests/rustdoc/doctest-include-43153.rs
diff --git a/tests/rustdoc/issue-38219.rs b/tests/rustdoc/doctest-macro-38219.rs
similarity index 100%
rename from tests/rustdoc/issue-38219.rs
rename to tests/rustdoc/doctest-macro-38219.rs
diff --git a/tests/rustdoc/issue-48377.rs b/tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs
similarity index 100%
rename from tests/rustdoc/issue-48377.rs
rename to tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs
diff --git a/tests/rustdoc/issue-46767.rs b/tests/rustdoc/enum-variant-private-46767.rs
similarity index 100%
rename from tests/rustdoc/issue-46767.rs
rename to tests/rustdoc/enum-variant-private-46767.rs
diff --git a/tests/rustdoc/issue-46766.rs b/tests/rustdoc/enum-variant-reexport-46766.rs
similarity index 100%
rename from tests/rustdoc/issue-46766.rs
rename to tests/rustdoc/enum-variant-reexport-46766.rs
diff --git a/tests/rustdoc/issue-43701.rs b/tests/rustdoc/foreign-implementors-js-43701.rs
similarity index 100%
rename from tests/rustdoc/issue-43701.rs
rename to tests/rustdoc/foreign-implementors-js-43701.rs
diff --git a/tests/rustdoc/issue-34423.rs b/tests/rustdoc/ice-34423.rs
similarity index 100%
rename from tests/rustdoc/issue-34423.rs
rename to tests/rustdoc/ice-34423.rs
diff --git a/tests/rustdoc/issue-36031.rs b/tests/rustdoc/ice-36031.rs
similarity index 100%
rename from tests/rustdoc/issue-36031.rs
rename to tests/rustdoc/ice-36031.rs
diff --git a/tests/rustdoc/issue-46976.rs b/tests/rustdoc/ice-apit-46976.rs
similarity index 100%
rename from tests/rustdoc/issue-46976.rs
rename to tests/rustdoc/ice-apit-46976.rs
diff --git a/tests/rustdoc/issue-48414.rs b/tests/rustdoc/ice-circular-intra-doc-link-48414.rs
similarity index 100%
rename from tests/rustdoc/issue-48414.rs
rename to tests/rustdoc/ice-circular-intra-doc-link-48414.rs
diff --git a/tests/rustdoc/issue-40936.rs b/tests/rustdoc/ice-extern-crate-40936.rs
similarity index 100%
rename from tests/rustdoc/issue-40936.rs
rename to tests/rustdoc/ice-extern-crate-40936.rs
diff --git a/tests/rustdoc/issue-46271.rs b/tests/rustdoc/ice-nested-extern-crate-46271.rs
similarity index 100%
rename from tests/rustdoc/issue-46271.rs
rename to tests/rustdoc/ice-nested-extern-crate-46271.rs
diff --git a/tests/rustdoc/issue-47639.rs b/tests/rustdoc/ice-nested-macro-rules-47639.rs
similarity index 100%
rename from tests/rustdoc/issue-47639.rs
rename to tests/rustdoc/ice-nested-macro-rules-47639.rs
diff --git a/tests/rustdoc/issue-34473.rs b/tests/rustdoc/inline-rename-34473.rs
similarity index 100%
rename from tests/rustdoc/issue-34473.rs
rename to tests/rustdoc/inline-rename-34473.rs
diff --git a/tests/rustdoc/issue-47038.rs b/tests/rustdoc/private-use-decl-macro-47038.rs
similarity index 100%
rename from tests/rustdoc/issue-47038.rs
rename to tests/rustdoc/private-use-decl-macro-47038.rs
diff --git a/tests/rustdoc/issue-46506-pub-reexport-of-pub-reexport.rs b/tests/rustdoc/pub-reexport-of-pub-reexport-46506.rs
similarity index 100%
rename from tests/rustdoc/issue-46506-pub-reexport-of-pub-reexport.rs
rename to tests/rustdoc/pub-reexport-of-pub-reexport-46506.rs
diff --git a/tests/rustdoc/issue-43893.rs b/tests/rustdoc/src-links-implementor-43893.rs
similarity index 100%
rename from tests/rustdoc/issue-43893.rs
rename to tests/rustdoc/src-links-implementor-43893.rs
diff --git a/tests/rustdoc/issue-45584.rs b/tests/rustdoc/trait-implementations-duplicate-self-45584.rs
similarity index 100%
rename from tests/rustdoc/issue-45584.rs
rename to tests/rustdoc/trait-implementations-duplicate-self-45584.rs
diff --git a/tests/rustdoc/issue-34928.rs b/tests/rustdoc/tuple-struct-34928.rs
similarity index 100%
rename from tests/rustdoc/issue-34928.rs
rename to tests/rustdoc/tuple-struct-34928.rs

From da7e87ef7042563f89204b4b2b4bb343e18696c5 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 20 Nov 2023 11:50:25 -0700
Subject: [PATCH 29/71] Add URL to test cases

---
 tests/rustdoc/doctest-include-43153.rs                      | 2 ++
 tests/rustdoc/doctest-macro-38219.rs                        | 2 ++
 tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs   | 2 ++
 tests/rustdoc/enum-variant-private-46767.rs                 | 1 +
 tests/rustdoc/enum-variant-reexport-46766.rs                | 1 +
 tests/rustdoc/foreign-implementors-js-43701.rs              | 1 +
 tests/rustdoc/ice-34423.rs                                  | 2 ++
 tests/rustdoc/ice-36031.rs                                  | 2 ++
 tests/rustdoc/ice-apit-46976.rs                             | 2 ++
 tests/rustdoc/ice-circular-intra-doc-link-48414.rs          | 2 ++
 tests/rustdoc/ice-extern-crate-40936.rs                     | 2 ++
 tests/rustdoc/ice-nested-extern-crate-46271.rs              | 2 ++
 tests/rustdoc/ice-nested-macro-rules-47639.rs               | 2 ++
 tests/rustdoc/inline-rename-34473.rs                        | 2 ++
 tests/rustdoc/private-use-decl-macro-47038.rs               | 2 ++
 tests/rustdoc/src-links-implementor-43893.rs                | 2 ++
 tests/rustdoc/trait-implementations-duplicate-self-45584.rs | 2 ++
 tests/rustdoc/tuple-struct-34928.rs                         | 2 ++
 18 files changed, 33 insertions(+)

diff --git a/tests/rustdoc/doctest-include-43153.rs b/tests/rustdoc/doctest-include-43153.rs
index 0fe680f10af..ec21a68c4ee 100644
--- a/tests/rustdoc/doctest-include-43153.rs
+++ b/tests/rustdoc/doctest-include-43153.rs
@@ -1,3 +1,5 @@
+// https://github.com/rust-lang/rust/issues/43153
+
 // Test that `include!` in a doc test searches relative to the directory in
 // which the test is declared.
 
diff --git a/tests/rustdoc/doctest-macro-38219.rs b/tests/rustdoc/doctest-macro-38219.rs
index fa57c58c761..6c81df11085 100644
--- a/tests/rustdoc/doctest-macro-38219.rs
+++ b/tests/rustdoc/doctest-macro-38219.rs
@@ -1,3 +1,5 @@
+// https://github.com/rust-lang/rust/issues/38219
+
 // compile-flags:--test
 // should-fail
 
diff --git a/tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs b/tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs
index c32bcf380ea..d481dc0dd70 100644
--- a/tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs
+++ b/tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs
@@ -1,5 +1,7 @@
 // compile-flags:--test
 
+// https://github.com/rust-lang/rust/issues/48377
+
 //! This is a doc comment
 //!
 //! ```rust
diff --git a/tests/rustdoc/enum-variant-private-46767.rs b/tests/rustdoc/enum-variant-private-46767.rs
index ef6ed104b74..6386aa75a95 100644
--- a/tests/rustdoc/enum-variant-private-46767.rs
+++ b/tests/rustdoc/enum-variant-private-46767.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/46767
 #![crate_name = "foo"]
 
 mod private {
diff --git a/tests/rustdoc/enum-variant-reexport-46766.rs b/tests/rustdoc/enum-variant-reexport-46766.rs
index 36ab739565b..ea6b7bac4c7 100644
--- a/tests/rustdoc/enum-variant-reexport-46766.rs
+++ b/tests/rustdoc/enum-variant-reexport-46766.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/46766
 #![crate_name = "foo"]
 
 pub enum Enum{Variant}
diff --git a/tests/rustdoc/foreign-implementors-js-43701.rs b/tests/rustdoc/foreign-implementors-js-43701.rs
index de772881e73..3b16ad2045a 100644
--- a/tests/rustdoc/foreign-implementors-js-43701.rs
+++ b/tests/rustdoc/foreign-implementors-js-43701.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/43701
 #![crate_name = "foo"]
 
 pub use std::vec::Vec;
diff --git a/tests/rustdoc/ice-34423.rs b/tests/rustdoc/ice-34423.rs
index b429bf8c9ba..42e57ac7258 100644
--- a/tests/rustdoc/ice-34423.rs
+++ b/tests/rustdoc/ice-34423.rs
@@ -1,3 +1,5 @@
+// https://github.com/rust-lang/rust/issues/34423
+
 pub struct Foo;
 
 pub trait Bar {
diff --git a/tests/rustdoc/ice-36031.rs b/tests/rustdoc/ice-36031.rs
index af1b32fd22b..9f091384dfe 100644
--- a/tests/rustdoc/ice-36031.rs
+++ b/tests/rustdoc/ice-36031.rs
@@ -2,6 +2,8 @@
 // build-aux-docs
 // ignore-cross-compile
 
+// https://github.com/rust-lang/rust/issues/36031
+
 #![crate_name = "foo"]
 
 extern crate issue_36031;
diff --git a/tests/rustdoc/ice-apit-46976.rs b/tests/rustdoc/ice-apit-46976.rs
index c59f8c72e64..e51cee2f056 100644
--- a/tests/rustdoc/ice-apit-46976.rs
+++ b/tests/rustdoc/ice-apit-46976.rs
@@ -1 +1,3 @@
+// https://github.com/rust-lang/rust/issues/46976
+
 pub fn ice(f: impl Fn()) {}
diff --git a/tests/rustdoc/ice-circular-intra-doc-link-48414.rs b/tests/rustdoc/ice-circular-intra-doc-link-48414.rs
index b35743d887b..68dda3a25bb 100644
--- a/tests/rustdoc/ice-circular-intra-doc-link-48414.rs
+++ b/tests/rustdoc/ice-circular-intra-doc-link-48414.rs
@@ -1,5 +1,7 @@
 // aux-build:issue-48414.rs
 
+// https://github.com/rust-lang/rust/issues/48414
+
 // ICE when resolving paths for a trait that linked to another trait, when both were in an external
 // crate
 
diff --git a/tests/rustdoc/ice-extern-crate-40936.rs b/tests/rustdoc/ice-extern-crate-40936.rs
index 4d2e4c17b1f..fafa4597174 100644
--- a/tests/rustdoc/ice-extern-crate-40936.rs
+++ b/tests/rustdoc/ice-extern-crate-40936.rs
@@ -1,6 +1,8 @@
 // aux-build:issue-40936.rs
 // build-aux-docs
 
+// https://github.com/rust-lang/rust/issues/40936
+
 #![crate_name = "foo"]
 
 extern crate issue_40936;
diff --git a/tests/rustdoc/ice-nested-extern-crate-46271.rs b/tests/rustdoc/ice-nested-extern-crate-46271.rs
index b38ef20c551..820a63f3498 100644
--- a/tests/rustdoc/ice-nested-extern-crate-46271.rs
+++ b/tests/rustdoc/ice-nested-extern-crate-46271.rs
@@ -1,5 +1,7 @@
 // hopefully this doesn't cause an ICE
 
+// https://github.com/rust-lang/rust/issues/46271
+
 pub fn foo() {
     extern crate std;
 }
diff --git a/tests/rustdoc/ice-nested-macro-rules-47639.rs b/tests/rustdoc/ice-nested-macro-rules-47639.rs
index 4b3456b86c5..c38dc2810cf 100644
--- a/tests/rustdoc/ice-nested-macro-rules-47639.rs
+++ b/tests/rustdoc/ice-nested-macro-rules-47639.rs
@@ -1,4 +1,6 @@
 // This should not ICE
+
+// https://github.com/rust-lang/rust/issues/47639
 pub fn test() {
     macro_rules! foo {
         () => ()
diff --git a/tests/rustdoc/inline-rename-34473.rs b/tests/rustdoc/inline-rename-34473.rs
index 37da3dd1999..7bc92cca1af 100644
--- a/tests/rustdoc/inline-rename-34473.rs
+++ b/tests/rustdoc/inline-rename-34473.rs
@@ -1,5 +1,7 @@
 #![crate_name = "foo"]
 
+// https://github.com/rust-lang/rust/issues/34473
+
 mod second {
     pub struct SomeTypeWithLongName;
 }
diff --git a/tests/rustdoc/private-use-decl-macro-47038.rs b/tests/rustdoc/private-use-decl-macro-47038.rs
index 810ddca3eab..8944bdd42b4 100644
--- a/tests/rustdoc/private-use-decl-macro-47038.rs
+++ b/tests/rustdoc/private-use-decl-macro-47038.rs
@@ -2,6 +2,8 @@
 
 #![crate_name = "foo"]
 
+// https://github.com/rust-lang/rust/issues/47038
+
 use std::vec;
 
 // @has 'foo/index.html'
diff --git a/tests/rustdoc/src-links-implementor-43893.rs b/tests/rustdoc/src-links-implementor-43893.rs
index 95d55193459..c16837b6129 100644
--- a/tests/rustdoc/src-links-implementor-43893.rs
+++ b/tests/rustdoc/src-links-implementor-43893.rs
@@ -1,5 +1,7 @@
 // ignore-cross-compile
 
+// https://github.com/rust-lang/rust/issues/43893
+
 #![crate_name = "foo"]
 
 pub trait SomeTrait {}
diff --git a/tests/rustdoc/trait-implementations-duplicate-self-45584.rs b/tests/rustdoc/trait-implementations-duplicate-self-45584.rs
index 8a5f0413826..77b8c05f2fb 100644
--- a/tests/rustdoc/trait-implementations-duplicate-self-45584.rs
+++ b/tests/rustdoc/trait-implementations-duplicate-self-45584.rs
@@ -1,5 +1,7 @@
 #![crate_name = "foo"]
 
+// https://github.com/rust-lang/rust/issues/45584
+
 pub trait Bar<T, U> {}
 
 // @has 'foo/struct.Foo1.html'
diff --git a/tests/rustdoc/tuple-struct-34928.rs b/tests/rustdoc/tuple-struct-34928.rs
index 4184086f622..909b9146893 100644
--- a/tests/rustdoc/tuple-struct-34928.rs
+++ b/tests/rustdoc/tuple-struct-34928.rs
@@ -1,5 +1,7 @@
 #![crate_name = "foo"]
 
+// https://github.com/rust-lang/rust/issues/34928
+
 pub trait Bar {}
 
 // @has foo/struct.Foo.html '//pre' 'pub struct Foo<T>(pub T) where T: Bar;'

From cbe68435c603da438b8994c1a583b46fc01821cf Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 20 Nov 2023 11:59:29 -0700
Subject: [PATCH 30/71] Fix src link URLs for file rename

---
 tests/rustdoc/src-links-implementor-43893.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/rustdoc/src-links-implementor-43893.rs b/tests/rustdoc/src-links-implementor-43893.rs
index c16837b6129..07e672847ca 100644
--- a/tests/rustdoc/src-links-implementor-43893.rs
+++ b/tests/rustdoc/src-links-implementor-43893.rs
@@ -7,15 +7,15 @@
 pub trait SomeTrait {}
 pub struct SomeStruct;
 
-// @has foo/trait.SomeTrait.html '//a/@href' '../src/foo/issue-43893.rs.html#9'
+// @has foo/trait.SomeTrait.html '//a/@href' '../src/foo/src-links-implementor-43893.rs.html#11'
 impl SomeTrait for usize {}
 
-// @has foo/trait.SomeTrait.html '//a/@href' '../src/foo/issue-43893.rs.html#12-14'
+// @has foo/trait.SomeTrait.html '//a/@href' '../src/foo/src-links-implementor-43893.rs.html#14-16'
 impl SomeTrait for SomeStruct {
     // deliberately multi-line impl
 }
 
 pub trait AnotherTrait {}
 
-// @has foo/trait.AnotherTrait.html '//a/@href' '../src/foo/issue-43893.rs.html#19'
+// @has foo/trait.AnotherTrait.html '//a/@href' '../src/foo/src-links-implementor-43893.rs.html#21'
 impl<T> AnotherTrait for T {}

From f697a00f760c17547ef4282fd6af5b9f3c433dcf Mon Sep 17 00:00:00 2001
From: Lukas Markeffsky <@>
Date: Tue, 21 Nov 2023 11:43:29 +0000
Subject: [PATCH 31/71] improve help for multiple `#[default]` variants

---
 .../src/deriving/default.rs                   | 17 +++--
 tests/ui/deriving/issue-105101.rs             |  9 ---
 tests/ui/deriving/issue-105101.stderr         | 29 ---------
 tests/ui/deriving/multiple-defaults.rs        | 41 ++++++++++++
 tests/ui/deriving/multiple-defaults.stderr    | 62 +++++++++++++++++++
 5 files changed, 111 insertions(+), 47 deletions(-)
 delete mode 100644 tests/ui/deriving/issue-105101.rs
 delete mode 100644 tests/ui/deriving/issue-105101.stderr
 create mode 100644 tests/ui/deriving/multiple-defaults.rs
 create mode 100644 tests/ui/deriving/multiple-defaults.stderr

diff --git a/compiler/rustc_builtin_macros/src/deriving/default.rs b/compiler/rustc_builtin_macros/src/deriving/default.rs
index 07b172bc757..43874a242f2 100644
--- a/compiler/rustc_builtin_macros/src/deriving/default.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/default.rs
@@ -127,18 +127,17 @@ fn extract_default_variant<'a>(
         [first, rest @ ..] => {
             let suggs = default_variants
                 .iter()
-                .map(|variant| {
-                    let spans = default_variants
+                .filter_map(|variant| {
+                    let keep = attr::find_by_name(&variant.attrs, kw::Default)?.span;
+                    let spans: Vec<Span> = default_variants
                         .iter()
-                        .filter_map(|v| {
-                            if v.span == variant.span {
-                                None
-                            } else {
-                                Some(attr::find_by_name(&v.attrs, kw::Default)?.span)
-                            }
+                        .flat_map(|v| {
+                            attr::filter_by_name(&v.attrs, kw::Default)
+                                .filter_map(|attr| (attr.span != keep).then_some(attr.span))
                         })
                         .collect();
-                    errors::MultipleDefaultsSugg { spans, ident: variant.ident }
+                    (!spans.is_empty())
+                        .then_some(errors::MultipleDefaultsSugg { spans, ident: variant.ident })
                 })
                 .collect();
             cx.emit_err(errors::MultipleDefaults {
diff --git a/tests/ui/deriving/issue-105101.rs b/tests/ui/deriving/issue-105101.rs
deleted file mode 100644
index 1a377feb919..00000000000
--- a/tests/ui/deriving/issue-105101.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// compile-flags: --crate-type=lib
-
-#[derive(Default)] //~ ERROR multiple declared defaults
-enum E {
-    #[default]
-    A,
-    #[default]
-    A, //~ ERROR defined multiple times
-}
diff --git a/tests/ui/deriving/issue-105101.stderr b/tests/ui/deriving/issue-105101.stderr
deleted file mode 100644
index 0f6f67043f3..00000000000
--- a/tests/ui/deriving/issue-105101.stderr
+++ /dev/null
@@ -1,29 +0,0 @@
-error: multiple declared defaults
-  --> $DIR/issue-105101.rs:3:10
-   |
-LL | #[derive(Default)]
-   |          ^^^^^^^
-...
-LL |     A,
-   |     - first default
-LL |     #[default]
-LL |     A,
-   |     - additional default
-   |
-   = note: only one variant can be default
-   = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0428]: the name `A` is defined multiple times
-  --> $DIR/issue-105101.rs:8:5
-   |
-LL |     A,
-   |     - previous definition of the type `A` here
-LL |     #[default]
-LL |     A,
-   |     ^ `A` redefined here
-   |
-   = note: `A` must be defined only once in the type namespace of this enum
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/deriving/multiple-defaults.rs b/tests/ui/deriving/multiple-defaults.rs
new file mode 100644
index 00000000000..2024a55200b
--- /dev/null
+++ b/tests/ui/deriving/multiple-defaults.rs
@@ -0,0 +1,41 @@
+// compile-flags: --crate-type=lib
+
+// When we get multiple `#[default]` variants, we emit several tool-only suggestions
+// to remove all except one of the `#[default]`s.
+
+#[derive(Default)] //~ ERROR multiple declared defaults
+enum A {
+    #[default] //~ HELP make `B` default
+    #[default] //~ HELP make `A` default
+    A,
+    #[default] // also "HELP make `A` default", but compiletest can't handle multispans
+    B,
+}
+
+// Originally, we took each defaulted variant and emitted the suggestion for every variant
+// with a different identifier, causing an ICE when multiple variants have the same identifier:
+// https://github.com/rust-lang/rust/pull/105106
+#[derive(Default)] //~ ERROR multiple declared defaults
+enum E {
+    #[default] //~ HELP make `A` default
+    A,
+    #[default] //~ HELP make `A` default
+    A, //~ ERROR defined multiple times
+}
+
+// Then, we took each defaulted variant and emitted the suggestion for every variant
+// with a different span, causing an ICE when multiple variants have the same span:
+// https://github.com/rust-lang/rust/issues/118119
+macro_rules! m {
+    { $($id:ident)* } => {
+        #[derive(Default)] //~ ERROR multiple declared defaults
+        enum F {
+            $(
+                #[default]
+                $id,
+            )*
+        }
+    }
+}
+
+m! { A B }
diff --git a/tests/ui/deriving/multiple-defaults.stderr b/tests/ui/deriving/multiple-defaults.stderr
new file mode 100644
index 00000000000..05fb6fecffa
--- /dev/null
+++ b/tests/ui/deriving/multiple-defaults.stderr
@@ -0,0 +1,62 @@
+error: multiple declared defaults
+  --> $DIR/multiple-defaults.rs:6:10
+   |
+LL | #[derive(Default)]
+   |          ^^^^^^^
+...
+LL |     A,
+   |     - first default
+LL |     #[default] // also "HELP make `A` default", but compiletest can't handle multispans
+LL |     B,
+   |     - additional default
+   |
+   = note: only one variant can be default
+   = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: multiple declared defaults
+  --> $DIR/multiple-defaults.rs:18:10
+   |
+LL | #[derive(Default)]
+   |          ^^^^^^^
+...
+LL |     A,
+   |     - first default
+LL |     #[default]
+LL |     A,
+   |     - additional default
+   |
+   = note: only one variant can be default
+   = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0428]: the name `A` is defined multiple times
+  --> $DIR/multiple-defaults.rs:23:5
+   |
+LL |     A,
+   |     - previous definition of the type `A` here
+LL |     #[default]
+LL |     A,
+   |     ^ `A` redefined here
+   |
+   = note: `A` must be defined only once in the type namespace of this enum
+
+error: multiple declared defaults
+  --> $DIR/multiple-defaults.rs:31:18
+   |
+LL |         #[derive(Default)]
+   |                  ^^^^^^^
+...
+LL |                 $id,
+   |                 ---
+   |                 |
+   |                 first default
+   |                 additional default
+...
+LL | m! { A B }
+   | ---------- in this macro invocation
+   |
+   = note: only one variant can be default
+   = note: this error originates in the derive macro `Default` which comes from the expansion of the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0428`.

From 32fc54e5fa97cf4ed69ea97dcf631d747a33faae Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 22 Nov 2023 07:25:27 +0100
Subject: [PATCH 32/71] make the 'abi_unadjusted' feature internal

---
 compiler/rustc_feature/src/unstable.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index b11b190bded..86e1825d7b5 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -160,7 +160,7 @@ declare_features! (
     // no-tracking-issue-start
 
     /// Allows using the `unadjusted` ABI; perma-unstable.
-    (unstable, abi_unadjusted, "1.16.0", None, None),
+    (internal, abi_unadjusted, "1.16.0", None, None),
     /// Allows using the `vectorcall` ABI.
     (unstable, abi_vectorcall, "1.7.0", None, None),
     /// Allows using `#![needs_allocator]`, an implementation detail of `#[global_allocator]`.

From d5e4bd89222c149cec295757fe203b58aa522edf Mon Sep 17 00:00:00 2001
From: SparrowLii <liyuan179@huawei.com>
Date: Wed, 22 Nov 2023 15:28:09 +0800
Subject: [PATCH 33/71] print query map for deadlock when using parallel front
 end

---
 compiler/rustc_query_system/src/query/job.rs     | 16 +++++++++++-----
 .../rustc_query_system/src/query/plumbing.rs     |  2 +-
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs
index f2c1f84fccc..726bda76b01 100644
--- a/compiler/rustc_query_system/src/query/job.rs
+++ b/compiler/rustc_query_system/src/query/job.rs
@@ -38,7 +38,7 @@ pub struct QueryInfo {
 pub type QueryMap = FxHashMap<QueryJobId, QueryJobInfo>;
 
 /// A value uniquely identifying an active query job.
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub struct QueryJobId(pub NonZeroU64);
 
 impl QueryJobId {
@@ -62,14 +62,14 @@ impl QueryJobId {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct QueryJobInfo {
     pub query: QueryStackFrame,
     pub job: QueryJob,
 }
 
 /// Represents an active query job.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct QueryJob {
     pub id: QueryJobId,
 
@@ -182,6 +182,7 @@ impl QueryJobId {
 }
 
 #[cfg(parallel_compiler)]
+#[derive(Debug)]
 struct QueryWaiter {
     query: Option<QueryJobId>,
     condvar: Condvar,
@@ -198,13 +199,14 @@ impl QueryWaiter {
 }
 
 #[cfg(parallel_compiler)]
+#[derive(Debug)]
 struct QueryLatchInfo {
     complete: bool,
     waiters: Vec<Arc<QueryWaiter>>,
 }
 
 #[cfg(parallel_compiler)]
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(super) struct QueryLatch {
     info: Arc<Mutex<QueryLatchInfo>>,
 }
@@ -540,7 +542,11 @@ pub fn deadlock(query_map: QueryMap, registry: &rayon_core::Registry) {
     // X to Y due to Rayon waiting and a true dependency from Y to X. The algorithm here
     // only considers the true dependency and won't detect a cycle.
     if !found_cycle {
-        panic!("deadlock detected");
+        if query_map.len() == 0 {
+            panic!("deadlock detected without any query!")
+        } else {
+            panic!("deadlock detected! current query map:\n{:?}", query_map);
+        }
     }
 
     // FIXME: Ensure this won't cause a deadlock before we return
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
index 6c08df99e9d..ecbc7dc6b8f 100644
--- a/compiler/rustc_query_system/src/query/plumbing.rs
+++ b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -203,7 +203,7 @@ where
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct CycleError {
     /// The query and related span that uses the cycle.
     pub usage: Option<(Span, QueryStackFrame)>,

From d5afea51dc5e3b9d8898e5ae176d71224566d956 Mon Sep 17 00:00:00 2001
From: "Celina G. Val" <celinval@amazon.com>
Date: Tue, 21 Nov 2023 13:41:02 -0800
Subject: [PATCH 34/71] Add CrateDef trait and methods to get def names

---
 compiler/rustc_smir/src/rustc_smir/mod.rs     |  34 +++++-
 compiler/stable_mir/src/crate_def.rs          |  66 +++++++++++
 compiler/stable_mir/src/lib.rs                |  27 +++--
 compiler/stable_mir/src/mir/mono.rs           |  26 ++++-
 compiler/stable_mir/src/mir/pretty.rs         |   1 +
 compiler/stable_mir/src/ty.rs                 |  73 +++++++-----
 .../stable-mir/check_allocation.rs            |   1 +
 tests/ui-fulldeps/stable-mir/check_defs.rs    | 106 ++++++++++++++++++
 tests/ui-fulldeps/stable-mir/crate-info.rs    |   1 +
 tests/ui-fulldeps/stable-mir/projections.rs   |   1 +
 10 files changed, 285 insertions(+), 51 deletions(-)
 create mode 100644 compiler/stable_mir/src/crate_def.rs
 create mode 100644 tests/ui-fulldeps/stable-mir/check_defs.rs

diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
index 403c7703deb..dea881a2bb3 100644
--- a/compiler/rustc_smir/src/rustc_smir/mod.rs
+++ b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -14,6 +14,7 @@ use rustc_hir::def::DefKind;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::{alloc_range, AllocId};
 use rustc_middle::mir::mono::MonoItem;
+use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths};
 use rustc_middle::ty::{self, Instance, ParamEnv, ScalarInt, Ty, TyCtxt, Variance};
 use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_target::abi::FieldIdx;
@@ -28,7 +29,7 @@ use stable_mir::ty::{
     EarlyParamRegion, FloatTy, FnDef, GenericArgs, GenericParamDef, IntTy, LineInfo, Movability,
     RigidTy, Span, TyKind, UintTy,
 };
-use stable_mir::{self, opaque, Context, CrateItem, Error, Filename, ItemKind};
+use stable_mir::{self, opaque, Context, Crate, CrateItem, Error, Filename, ItemKind, Symbol};
 use std::cell::RefCell;
 use tracing::debug;
 
@@ -61,9 +62,18 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
         crates
     }
 
-    fn name_of_def_id(&self, def_id: stable_mir::DefId) -> String {
+    fn def_name(&self, def_id: stable_mir::DefId, trimmed: bool) -> Symbol {
         let tables = self.0.borrow();
-        tables.tcx.def_path_str(tables[def_id])
+        if trimmed {
+            with_forced_trimmed_paths!(tables.tcx.def_path_str(tables[def_id]))
+        } else {
+            with_no_trimmed_paths!(tables.tcx.def_path_str(tables[def_id]))
+        }
+    }
+
+    fn krate(&self, def_id: stable_mir::DefId) -> Crate {
+        let tables = self.0.borrow();
+        smir_crate(tables.tcx, tables[def_id].krate)
     }
 
     fn span_to_string(&self, span: stable_mir::ty::Span) -> String {
@@ -240,10 +250,24 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
         tables.create_def_id(def_id)
     }
 
-    fn instance_mangled_name(&self, def: InstanceDef) -> String {
+    fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol {
+        let tables = self.0.borrow_mut();
+        let instance = tables.instances[instance];
+        tables.tcx.symbol_name(instance).name.to_string()
+    }
+
+    fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol {
         let tables = self.0.borrow_mut();
         let instance = tables.instances[def];
-        tables.tcx.symbol_name(instance).name.to_string()
+        if trimmed {
+            with_forced_trimmed_paths!(
+                tables.tcx.def_path_str_with_args(instance.def_id(), instance.args)
+            )
+        } else {
+            with_no_trimmed_paths!(
+                tables.tcx.def_path_str_with_args(instance.def_id(), instance.args)
+            )
+        }
     }
 
     fn mono_instance(&self, item: stable_mir::CrateItem) -> stable_mir::mir::mono::Instance {
diff --git a/compiler/stable_mir/src/crate_def.rs b/compiler/stable_mir/src/crate_def.rs
new file mode 100644
index 00000000000..accd078b1ce
--- /dev/null
+++ b/compiler/stable_mir/src/crate_def.rs
@@ -0,0 +1,66 @@
+//! Module that define a common trait for things that represent a crate definition.
+
+use crate::ty::Span;
+use crate::{with, Crate, Symbol};
+
+/// A unique identification number for each item accessible for the current compilation unit.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DefId(pub(crate) usize);
+
+/// A trait for retrieving information about a crate definition.
+///
+/// Implementors must provide the implementation of `def_id` which will be used to retrieve
+/// information about its definition.
+pub trait CrateDef {
+    /// Retrieve the unique identifier for the given definition.
+    fn def_id(&self) -> DefId;
+
+    /// Return the fully qualified name of the given definition.
+    fn name(&self) -> Symbol {
+        let def_id = self.def_id();
+        with(|cx| cx.def_name(def_id, false))
+    }
+
+    /// Return a trimmed name of the given definition.
+    ///
+    /// If a symbol name can only be imported from one place for a type, and as
+    /// long as it was not glob-imported anywhere in the current crate, we trim its
+    /// path and print only the name.
+    ///
+    /// For example, this function may shorten `std::vec::Vec` to just `Vec`,
+    /// as long as there is no other `Vec` importable anywhere.
+    fn trimmed_name(&self) -> Symbol {
+        let def_id = self.def_id();
+        with(|cx| cx.def_name(def_id, true))
+    }
+
+    /// Return information about the crate where this definition is declared.
+    ///
+    /// This will return the crate number and its name.
+    fn krate(&self) -> Crate {
+        let def_id = self.def_id();
+        with(|cx| cx.krate(def_id))
+    }
+
+    /// Return the span of this definition.
+    fn span(&self) -> Span {
+        let def_id = self.def_id();
+        with(|cx| cx.span_of_an_item(def_id))
+    }
+}
+
+macro_rules! crate_def {
+    ( $(#[$attr:meta])*
+      $vis:vis $name:ident $(;)?
+    ) => {
+        $(#[$attr])*
+        #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+        $vis struct $name(pub DefId);
+
+        impl CrateDef for $name {
+            fn def_id(&self) -> DefId {
+                self.0
+            }
+        }
+    };
+}
diff --git a/compiler/stable_mir/src/lib.rs b/compiler/stable_mir/src/lib.rs
index 6c1b723a8da..1b1faea4953 100644
--- a/compiler/stable_mir/src/lib.rs
+++ b/compiler/stable_mir/src/lib.rs
@@ -31,12 +31,16 @@ use self::ty::{
 #[macro_use]
 extern crate scoped_tls;
 
+#[macro_use]
+pub mod crate_def;
 #[macro_use]
 pub mod error;
 pub mod mir;
 pub mod ty;
 pub mod visitor;
 
+pub use crate::crate_def::CrateDef;
+pub use crate::crate_def::DefId;
 use crate::mir::alloc::{AllocId, GlobalAlloc};
 use crate::mir::pretty::function_name;
 use crate::mir::Mutability;
@@ -51,15 +55,11 @@ pub type Symbol = String;
 /// The number that identifies a crate.
 pub type CrateNum = usize;
 
-/// A unique identification number for each item accessible for the current compilation unit.
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub struct DefId(usize);
-
 impl Debug for DefId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("DefId")
             .field("id", &self.0)
-            .field("name", &with(|cx| cx.name_of_def_id(*self)))
+            .field("name", &with(|cx| cx.def_name(*self, false)))
             .finish()
     }
 }
@@ -100,9 +100,10 @@ pub enum ItemKind {
 
 pub type Filename = String;
 
-/// Holds information about an item in the crate.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct CrateItem(pub DefId);
+crate_def! {
+    /// Holds information about an item in a crate.
+    pub CrateItem;
+}
 
 impl CrateItem {
     pub fn body(&self) -> mir::Body {
@@ -113,10 +114,6 @@ impl CrateItem {
         with(|cx| cx.span_of_an_item(self.0))
     }
 
-    pub fn name(&self) -> String {
-        with(|cx| cx.name_of_def_id(self.0))
-    }
-
     pub fn kind(&self) -> ItemKind {
         with(|cx| cx.item_kind(*self))
     }
@@ -205,7 +202,7 @@ pub trait Context {
     fn find_crates(&self, name: &str) -> Vec<Crate>;
 
     /// Returns the name of given `DefId`
-    fn name_of_def_id(&self, def_id: DefId) -> String;
+    fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol;
 
     /// Returns printable, human readable form of `Span`
     fn span_to_string(&self, span: Span) -> String;
@@ -260,7 +257,7 @@ pub trait Context {
     fn instance_def_id(&self, instance: InstanceDef) -> DefId;
 
     /// Get the instance mangled name.
-    fn instance_mangled_name(&self, instance: InstanceDef) -> String;
+    fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol;
 
     /// Convert a non-generic crate item into an instance.
     /// This function will panic if the item is generic.
@@ -294,6 +291,8 @@ pub trait Context {
 
     /// Retrieve the id for the virtual table.
     fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option<AllocId>;
+    fn krate(&self, def_id: DefId) -> Crate;
+    fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol;
 }
 
 // A thread local variable that stores a pointer to the tables mapping between TyCtxt
diff --git a/compiler/stable_mir/src/mir/mono.rs b/compiler/stable_mir/src/mir/mono.rs
index 9cec963cf84..ddf601f6d76 100644
--- a/compiler/stable_mir/src/mir/mono.rs
+++ b/compiler/stable_mir/src/mir/mono.rs
@@ -1,6 +1,7 @@
+use crate::crate_def::CrateDef;
 use crate::mir::Body;
 use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, IndexedVal, Ty};
-use crate::{with, CrateItem, DefId, Error, ItemKind, Opaque};
+use crate::{with, CrateItem, DefId, Error, ItemKind, Opaque, Symbol};
 use std::fmt::{Debug, Formatter};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -47,10 +48,23 @@ impl Instance {
         with(|context| context.instance_ty(self.def))
     }
 
-    pub fn mangled_name(&self) -> String {
+    pub fn mangled_name(&self) -> Symbol {
         with(|context| context.instance_mangled_name(self.def))
     }
 
+    pub fn name(&self) -> Symbol {
+        with(|context| context.instance_name(self.def, false))
+    }
+
+    /// Return a trimmed name of the given instance including its args.
+    ///
+    /// If a symbol name can only be imported from one place for a type, and as
+    /// long as it was not glob-imported anywhere in the current crate, we trim its
+    /// path and print only the name.
+    pub fn trimmed_name(&self) -> Symbol {
+        with(|context| context.instance_name(self.def, true))
+    }
+
     /// Resolve an instance starting from a function definition and generic arguments.
     pub fn resolve(def: FnDef, args: &GenericArgs) -> Result<Instance, crate::Error> {
         with(|context| {
@@ -104,6 +118,8 @@ impl TryFrom<CrateItem> for Instance {
 
     fn try_from(item: CrateItem) -> Result<Self, Self::Error> {
         with(|context| {
+            /// FIXME(celinval):
+            /// - Check `has_body`.
             if !context.requires_monomorphization(item.0) {
                 Ok(context.mono_instance(item))
             } else {
@@ -148,8 +164,10 @@ impl From<StaticDef> for CrateItem {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct InstanceDef(usize);
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-pub struct StaticDef(pub DefId);
+crate_def! {
+    /// Holds information about a static variable definition.
+    pub StaticDef;
+}
 
 impl TryFrom<CrateItem> for StaticDef {
     type Error = crate::Error;
diff --git a/compiler/stable_mir/src/mir/pretty.rs b/compiler/stable_mir/src/mir/pretty.rs
index c7422d66c0e..c16d7ddf335 100644
--- a/compiler/stable_mir/src/mir/pretty.rs
+++ b/compiler/stable_mir/src/mir/pretty.rs
@@ -1,3 +1,4 @@
+use crate::crate_def::CrateDef;
 use crate::mir::{Operand, Rvalue, StatementKind};
 use crate::ty::{DynKind, FloatTy, IntTy, RigidTy, TyKind, UintTy};
 use crate::{with, Body, CrateItem, Mutability};
diff --git a/compiler/stable_mir/src/ty.rs b/compiler/stable_mir/src/ty.rs
index 010e2e7e4a6..cf97d1a6f0b 100644
--- a/compiler/stable_mir/src/ty.rs
+++ b/compiler/stable_mir/src/ty.rs
@@ -3,6 +3,7 @@ use super::{
     mir::{Body, Mutability},
     with, DefId, Error, Symbol,
 };
+use crate::crate_def::CrateDef;
 use crate::mir::alloc::AllocId;
 use crate::{Filename, Opaque};
 use std::fmt::{self, Debug, Display, Formatter};
@@ -295,11 +296,15 @@ pub enum Movability {
     Movable,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct ForeignDef(pub DefId);
+crate_def! {
+    /// Hold information about a ForeignItem in a crate.
+    pub ForeignDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct FnDef(pub DefId);
+crate_def! {
+    /// Hold information about a function definition in a crate.
+    pub FnDef;
+}
 
 impl FnDef {
     pub fn body(&self) -> Body {
@@ -307,20 +312,25 @@ impl FnDef {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct ClosureDef(pub DefId);
+crate_def! {
+    pub ClosureDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct CoroutineDef(pub DefId);
+crate_def! {
+    pub CoroutineDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct ParamDef(pub DefId);
+crate_def! {
+    pub ParamDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct BrNamedDef(pub DefId);
+crate_def! {
+    pub BrNamedDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct AdtDef(pub DefId);
+crate_def! {
+    pub AdtDef;
+}
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub enum AdtKind {
@@ -363,26 +373,33 @@ impl AdtKind {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct AliasDef(pub DefId);
+crate_def! {
+    pub AliasDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct TraitDef(pub DefId);
+crate_def! {
+    pub TraitDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct GenericDef(pub DefId);
+crate_def! {
+    pub GenericDef;
+}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct ConstDef(pub DefId);
+crate_def! {
+    pub ConstDef;
+}
 
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct ImplDef(pub DefId);
+crate_def! {
+    pub ImplDef;
+}
 
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct RegionDef(pub DefId);
+crate_def! {
+    pub RegionDef;
+}
 
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct CoroutineWitnessDef(pub DefId);
+crate_def! {
+    pub CoroutineWitnessDef;
+}
 
 /// A list of generic arguments.
 #[derive(Clone, Debug, Eq, PartialEq)]
diff --git a/tests/ui-fulldeps/stable-mir/check_allocation.rs b/tests/ui-fulldeps/stable-mir/check_allocation.rs
index e5fb7311c0b..170b1fd73b1 100644
--- a/tests/ui-fulldeps/stable-mir/check_allocation.rs
+++ b/tests/ui-fulldeps/stable-mir/check_allocation.rs
@@ -24,6 +24,7 @@ extern crate stable_mir;
 use rustc_middle::ty::TyCtxt;
 use rustc_smir::rustc_internal;
 use stable_mir::{CrateItem, CrateItems, ItemKind};
+use stable_mir::crate_def::CrateDef;
 use stable_mir::mir::alloc::GlobalAlloc;
 use stable_mir::mir::mono::StaticDef;
 use std::ascii::Char;
diff --git a/tests/ui-fulldeps/stable-mir/check_defs.rs b/tests/ui-fulldeps/stable-mir/check_defs.rs
new file mode 100644
index 00000000000..bbb49596288
--- /dev/null
+++ b/tests/ui-fulldeps/stable-mir/check_defs.rs
@@ -0,0 +1,106 @@
+// run-pass
+//! Test that users are able to use stable mir APIs to retrieve information about crate definitions.
+
+// ignore-stage1
+// ignore-cross-compile
+// ignore-remote
+// ignore-windows-gnu mingw has troubles with linking https://github.com/rust-lang/rust/pull/116837
+// edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+#![feature(control_flow_enum)]
+
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_smir;
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate stable_mir;
+
+use mir::{mono::Instance, TerminatorKind::*};
+use rustc_middle::ty::TyCtxt;
+use rustc_smir::rustc_internal;
+use stable_mir::ty::{RigidTy, TyKind};
+use stable_mir::*;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
+    let entry = stable_mir::entry_fn().unwrap();
+    let main_fn = Instance::try_from(entry).unwrap();
+    assert_eq!(main_fn.name(), "main");
+    assert_eq!(main_fn.trimmed_name(), "main");
+
+    let instances = get_instances(main_fn.body().unwrap());
+    assert_eq!(instances.len(), 2);
+    test_fn(instances[0], "from_u32", "std::char::from_u32", "core");
+    test_fn(instances[1], "Vec::<u8>::new", "std::vec::Vec::<u8>::new", "alloc");
+    ControlFlow::Continue(())
+}
+
+fn test_fn(instance: Instance, expected_trimmed: &str, expected_qualified: &str, krate: &str) {
+    let trimmed = instance.trimmed_name();
+    let qualified = instance.name();
+    assert_eq!(&trimmed, expected_trimmed);
+    assert_eq!(&qualified, expected_qualified);
+
+    let item = CrateItem::try_from(instance).unwrap();
+    let trimmed = item.trimmed_name();
+    let qualified = item.name();
+    assert_eq!(trimmed, expected_trimmed.replace("u8", "T"));
+    assert_eq!(qualified, expected_qualified.replace("u8", "T"));
+    assert_eq!(&item.krate().name, krate);
+}
+
+/// Inspect the instance body
+fn get_instances(body: mir::Body) -> Vec<Instance> {
+    body.blocks.iter().filter_map(|bb| {
+        match &bb.terminator.kind {
+            Call { func, .. } => {
+                let TyKind::RigidTy(ty) = func.ty(body.locals()).unwrap().kind() else { unreachable!
+                () };
+                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
+                Instance::resolve(def, &args).ok()
+            }
+            _ => {
+                None
+            }
+        }
+    }).collect::<Vec<_>>()
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "defs_input.rs";
+    generate_input(&path).unwrap();
+    let args = vec![
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, tcx, test_stable_mir(tcx)).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+
+        fn main() {{
+            let _c = core::char::from_u32(99);
+            let _v = Vec::<u8>::new();
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs
index 4164f041022..c2035430a33 100644
--- a/tests/ui-fulldeps/stable-mir/crate-info.rs
+++ b/tests/ui-fulldeps/stable-mir/crate-info.rs
@@ -23,6 +23,7 @@ use rustc_hir::def::DefKind;
 use rustc_middle::ty::TyCtxt;
 use rustc_smir::rustc_internal;
 use stable_mir::ItemKind;
+use stable_mir::crate_def::CrateDef;
 use stable_mir::mir::mono::Instance;
 use stable_mir::ty::{RigidTy, TyKind};
 use std::assert_matches::assert_matches;
diff --git a/tests/ui-fulldeps/stable-mir/projections.rs b/tests/ui-fulldeps/stable-mir/projections.rs
index 29930763591..8c3fda7b6bb 100644
--- a/tests/ui-fulldeps/stable-mir/projections.rs
+++ b/tests/ui-fulldeps/stable-mir/projections.rs
@@ -21,6 +21,7 @@ extern crate stable_mir;
 
 use rustc_middle::ty::TyCtxt;
 use rustc_smir::rustc_internal;
+use stable_mir::crate_def::CrateDef;
 use stable_mir::mir::{ProjectionElem, Rvalue, StatementKind};
 use stable_mir::ty::{RigidTy, TyKind, UintTy};
 use stable_mir::ItemKind;

From 591b41abb8d2c6e7b0798ad658e3cc49bc92b2df Mon Sep 17 00:00:00 2001
From: "Celina G. Val" <celinval@amazon.com>
Date: Tue, 21 Nov 2023 19:09:01 -0800
Subject: [PATCH 35/71] Provide conversion of stable span to internal span

This will allow users to use rustc span messages to display user
friendly messages.
---
 compiler/rustc_smir/src/rustc_internal/internal.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs
index fe226ef60ed..202ca1b156a 100644
--- a/compiler/rustc_smir/src/rustc_internal/internal.rs
+++ b/compiler/rustc_smir/src/rustc_internal/internal.rs
@@ -11,8 +11,8 @@ use stable_mir::mir::alloc::AllocId;
 use stable_mir::mir::mono::{Instance, MonoItem, StaticDef};
 use stable_mir::ty::{
     AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, Const,
-    ExistentialTraitRef, FloatTy, GenericArgKind, GenericArgs, IntTy, Region, RigidTy, TraitRef,
-    Ty, UintTy,
+    ExistentialTraitRef, FloatTy, GenericArgKind, GenericArgs, IntTy, Region, RigidTy, Span,
+    TraitRef, Ty, UintTy,
 };
 use stable_mir::{CrateItem, DefId};
 
@@ -279,6 +279,14 @@ impl<'tcx> RustcInternal<'tcx> for AdtDef {
     }
 }
 
+impl<'tcx> RustcInternal<'tcx> for Span {
+    type T = rustc_span::Span;
+
+    fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T {
+        tables[*self]
+    }
+}
+
 impl<'tcx, T> RustcInternal<'tcx> for &T
 where
     T: RustcInternal<'tcx>,

From 111ad61ab3917ac7f7b72c9d6f604a6ed4dbf8c3 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Thu, 23 Nov 2023 00:27:34 +0300
Subject: [PATCH 36/71] Recompile LLVM when it changes in the git sources

Utilize a smart hash for 'llvm-finished-building' to enable
recompilation of LLVM with each change in the git sources.

Each change generates a unique hash value in 'llvm-finished-building',
which ensures LLVM compilations only triggered with further changes.

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/build_steps/llvm.rs |  9 ++++-
 src/bootstrap/src/lib.rs                   | 43 ++++++++++++++++++++++
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index a1f6fac8a51..f710c01ca33 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -20,7 +20,7 @@ use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
 use crate::core::config::{Config, TargetSelection};
 use crate::utils::channel;
 use crate::utils::helpers::{self, exe, get_clang_cl_resource_dir, output, t, up_to_date};
-use crate::{CLang, GitRepo, Kind};
+use crate::{generate_smart_stamp_hash, CLang, GitRepo, Kind};
 
 use build_helper::ci::CiEnv;
 use build_helper::git::get_git_merge_base;
@@ -105,8 +105,13 @@ pub fn prebuilt_llvm_config(
     let llvm_cmake_dir = out_dir.join("lib/cmake/llvm");
     let res = LlvmResult { llvm_config: build_llvm_config, llvm_cmake_dir };
 
+    let smart_stamp_hash = generate_smart_stamp_hash(
+        &builder.config.src.join("src/llvm-project"),
+        &builder.in_tree_llvm_info.sha().unwrap_or_default(),
+    );
+
     let stamp = out_dir.join("llvm-finished-building");
-    let stamp = HashStamp::new(stamp, builder.in_tree_llvm_info.sha());
+    let stamp = HashStamp::new(stamp, Some(&smart_stamp_hash));
 
     if stamp.is_done() {
         if stamp.hash.is_none() {
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index a57b09e2ef6..c6e279ca9d8 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -31,6 +31,7 @@ use build_helper::exit;
 use build_helper::util::fail;
 use filetime::FileTime;
 use once_cell::sync::OnceCell;
+use sha2::digest::Digest;
 use termcolor::{ColorChoice, StandardStream, WriteColor};
 use utils::channel::GitInfo;
 
@@ -1872,3 +1873,45 @@ pub fn find_recent_config_change_ids(current_id: usize) -> Vec<usize> {
         .cloned()
         .collect()
 }
+
+/// Computes a hash representing the state of a repository/submodule and additional input.
+///
+/// It uses `git diff` for the actual changes, and `git status` for including the untracked
+/// files in the specified directory. The additional input is also incorporated into the
+/// computation of the hash.
+///
+/// # Parameters
+///
+/// - `dir`: A reference to the directory path of the target repository/submodule.
+/// - `additional_input`: An additional input to be included in the hash.
+///
+/// # Panics
+///
+/// In case of errors during `git` command execution (e.g., in tarball sources), default values
+/// are used to prevent panics.
+pub fn generate_smart_stamp_hash(dir: &Path, additional_input: &str) -> String {
+    let diff = Command::new("git")
+        .current_dir(dir)
+        .arg("diff")
+        .output()
+        .map(|o| String::from_utf8(o.stdout).unwrap_or_default())
+        .unwrap_or_default();
+
+    let status = Command::new("git")
+        .current_dir(dir)
+        .arg("status")
+        .arg("--porcelain")
+        .arg("-z")
+        .arg("--untracked-files=normal")
+        .output()
+        .map(|o| String::from_utf8(o.stdout).unwrap_or_default())
+        .unwrap_or_default();
+
+    let mut hasher = sha2::Sha256::new();
+
+    hasher.update(diff);
+    hasher.update(status);
+    hasher.update(additional_input);
+
+    hex::encode(hasher.finalize().as_slice())
+}

From 15fbcc363680ce100a563aac304c389d0f57dfd4 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 18 Nov 2023 19:29:39 +0000
Subject: [PATCH 37/71] Rework supertrait lint once again

---
 compiler/rustc_lint/messages.ftl              |  3 +-
 .../src/deref_into_dyn_supertrait.rs          | 42 +++++++++++--------
 compiler/rustc_lint/src/lints.rs              | 14 +++++--
 .../trait-upcasting/deref-lint-regions.stderr |  2 +-
 tests/ui/traits/trait-upcasting/deref-lint.rs |  1 +
 .../traits/trait-upcasting/deref-lint.stderr  |  4 +-
 .../deref-upcast-behavioral-change.rs         | 34 +++++++++++++++
 .../deref-upcast-behavioral-change.stderr     | 16 +++++++
 .../migrate-lint-different-substs.rs          | 20 +++++++++
 .../migrate-lint-different-substs.stderr      | 14 +++++++
 10 files changed, 125 insertions(+), 25 deletions(-)
 create mode 100644 tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.rs
 create mode 100644 tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr
 create mode 100644 tests/ui/traits/trait-upcasting/migrate-lint-different-substs.rs
 create mode 100644 tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 80b21bd8ece..2db610d640c 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -491,8 +491,9 @@ lint_requested_level = requested on the command line with `{$level} {$lint_name}
 lint_span_use_eq_ctxt = use `.eq_ctxt()` instead of `.ctxt() == .ctxt()`
 
 lint_supertrait_as_deref_target = this `Deref` implementation is covered by an implicit supertrait coercion
+    .label = `{$self_ty}` implements `Deref<Target = dyn {$target_principal}>` which conflicts with supertrait `{$supertrait_principal}`
+    .label2 = target type is a supertrait of `{$self_ty}`
     .help = consider removing this implementation or replacing it with a method instead
-    .label = target type is a supertrait of `{$t}`
 
 lint_suspicious_double_ref_clone =
     using `.clone()` on a double reference, which returns `{$ty}` instead of cloning the inner type
diff --git a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
index 93c7c37c655..98bafc0f263 100644
--- a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
+++ b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
@@ -53,35 +53,43 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
         let tcx = cx.tcx;
         // `Deref` is being implemented for `t`
         if let hir::ItemKind::Impl(impl_) = item.kind
+            // the trait is a `Deref` implementation
             && let Some(trait_) = &impl_.of_trait
-            && let t = tcx.type_of(item.owner_id).instantiate_identity()
-            && let opt_did @ Some(did) = trait_.trait_def_id()
-            && opt_did == tcx.lang_items().deref_trait()
-            // `t` is `dyn t_principal`
-            && let ty::Dynamic(data, _, ty::Dyn) = t.kind()
-            && let Some(t_principal) = data.principal()
+            && let Some(did) = trait_.trait_def_id()
+            && Some(did) == tcx.lang_items().deref_trait()
+            // the self type is `dyn t_principal`
+            && let self_ty = tcx.type_of(item.owner_id).instantiate_identity()
+            && let ty::Dynamic(data, _, ty::Dyn) = self_ty.kind()
+            && let Some(self_principal) = data.principal()
             // `<T as Deref>::Target` is `dyn target_principal`
-            && let Some(target) = cx.get_associated_type(t, did, "Target")
+            && let Some(target) = cx.get_associated_type(self_ty, did, "Target")
             && let ty::Dynamic(data, _, ty::Dyn) = target.kind()
             && let Some(target_principal) = data.principal()
             // `target_principal` is a supertrait of `t_principal`
-            && supertraits(tcx, t_principal.with_self_ty(tcx, tcx.types.trait_object_dummy_self))
-                .any(|sup| {
-                    tcx.erase_regions(
-                        sup.map_bound(|x| ty::ExistentialTraitRef::erase_self_ty(tcx, x)),
-                    ) == tcx.erase_regions(target_principal)
-                })
+            && let Some(supertrait_principal) = supertraits(tcx, self_principal.with_self_ty(tcx, self_ty))
+                .find(|supertrait| supertrait.def_id() == target_principal.def_id())
         {
-            let t = tcx.erase_regions(t);
-            let label = impl_
+            // erase regions in self type for better diagnostic presentation
+            let (self_ty, target_principal, supertrait_principal) =
+                tcx.erase_regions((self_ty, target_principal, supertrait_principal));
+            let label2 = impl_
                 .items
                 .iter()
                 .find_map(|i| (i.ident.name == sym::Target).then_some(i.span))
                 .map(|label| SupertraitAsDerefTargetLabel { label });
+            let span = tcx.def_span(item.owner_id.def_id);
             cx.emit_spanned_lint(
                 DEREF_INTO_DYN_SUPERTRAIT,
-                tcx.def_span(item.owner_id.def_id),
-                SupertraitAsDerefTarget { t, label },
+                span,
+                SupertraitAsDerefTarget {
+                    self_ty,
+                    supertrait_principal: supertrait_principal.map_bound(|trait_ref| {
+                        ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref)
+                    }),
+                    target_principal,
+                    label: span,
+                    label2,
+                },
             );
         }
     }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 7fe488e1243..9fda53c2533 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -10,7 +10,9 @@ use rustc_errors::{
 };
 use rustc_hir::def_id::DefId;
 use rustc_macros::{LintDiagnostic, Subdiagnostic};
-use rustc_middle::ty::{inhabitedness::InhabitedPredicate, Clause, Ty, TyCtxt};
+use rustc_middle::ty::{
+    inhabitedness::InhabitedPredicate, Clause, PolyExistentialTraitRef, Ty, TyCtxt,
+};
 use rustc_session::parse::ParseSess;
 use rustc_span::{edition::Edition, sym, symbol::Ident, Span, Symbol};
 
@@ -556,13 +558,17 @@ pub enum BuiltinSpecialModuleNameUsed {
 #[diag(lint_supertrait_as_deref_target)]
 #[help]
 pub struct SupertraitAsDerefTarget<'a> {
-    pub t: Ty<'a>,
+    pub self_ty: Ty<'a>,
+    pub supertrait_principal: PolyExistentialTraitRef<'a>,
+    pub target_principal: PolyExistentialTraitRef<'a>,
+    #[label]
+    pub label: Span,
     #[subdiagnostic]
-    pub label: Option<SupertraitAsDerefTargetLabel>,
+    pub label2: Option<SupertraitAsDerefTargetLabel>,
 }
 
 #[derive(Subdiagnostic)]
-#[label(lint_label)]
+#[label(lint_label2)]
 pub struct SupertraitAsDerefTargetLabel {
     #[primary_span]
     pub label: Span,
diff --git a/tests/ui/traits/trait-upcasting/deref-lint-regions.stderr b/tests/ui/traits/trait-upcasting/deref-lint-regions.stderr
index dd4aa8e9a07..557a4420a3d 100644
--- a/tests/ui/traits/trait-upcasting/deref-lint-regions.stderr
+++ b/tests/ui/traits/trait-upcasting/deref-lint-regions.stderr
@@ -2,7 +2,7 @@ warning: this `Deref` implementation is covered by an implicit supertrait coerci
   --> $DIR/deref-lint-regions.rs:8:1
    |
 LL | impl<'a> Deref for dyn Foo<'a> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo<'_>` implements `Deref<Target = dyn Bar<'_>>` which conflicts with supertrait `Bar<'_>`
 LL |
 LL |     type Target = dyn Bar<'a>;
    |     -------------------------- target type is a supertrait of `dyn Foo<'_>`
diff --git a/tests/ui/traits/trait-upcasting/deref-lint.rs b/tests/ui/traits/trait-upcasting/deref-lint.rs
index dfca7b0fa68..68838d2ae20 100644
--- a/tests/ui/traits/trait-upcasting/deref-lint.rs
+++ b/tests/ui/traits/trait-upcasting/deref-lint.rs
@@ -8,6 +8,7 @@ trait B: A {}
 
 impl<'a> Deref for dyn 'a + B {
     //~^ WARN this `Deref` implementation is covered by an implicit supertrait coercion
+
     type Target = dyn A;
     fn deref(&self) -> &Self::Target {
         todo!()
diff --git a/tests/ui/traits/trait-upcasting/deref-lint.stderr b/tests/ui/traits/trait-upcasting/deref-lint.stderr
index 0f7a61dfa80..5a13659edf5 100644
--- a/tests/ui/traits/trait-upcasting/deref-lint.stderr
+++ b/tests/ui/traits/trait-upcasting/deref-lint.stderr
@@ -2,8 +2,8 @@ warning: this `Deref` implementation is covered by an implicit supertrait coerci
   --> $DIR/deref-lint.rs:9:1
    |
 LL | impl<'a> Deref for dyn 'a + B {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-LL |
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn B` implements `Deref<Target = dyn A>` which conflicts with supertrait `A`
+...
 LL |     type Target = dyn A;
    |     -------------------- target type is a supertrait of `dyn B`
    |
diff --git a/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.rs b/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.rs
new file mode 100644
index 00000000000..366eae1a58a
--- /dev/null
+++ b/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.rs
@@ -0,0 +1,34 @@
+#![deny(deref_into_dyn_supertrait)]
+use std::ops::Deref;
+
+trait Bar<T> {}
+impl<T, U> Bar<U> for T {}
+
+trait Foo: Bar<i32> {
+    fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar<u32> + 'a);
+}
+
+impl Foo for () {
+    fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar<u32> + 'a) {
+        self
+    }
+}
+
+impl<'a> Deref for dyn Foo + 'a {
+    type Target = dyn Bar<u32> + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_dyn_bar_u32()
+    }
+}
+
+fn take_dyn<T>(x: &dyn Bar<T>) -> T {
+    todo!()
+}
+
+fn main() {
+    let x: &dyn Foo = &();
+    let y = take_dyn(x);
+    let z: u32 = y;
+    //~^ ERROR mismatched types
+}
diff --git a/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr b/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr
new file mode 100644
index 00000000000..e8bab322a38
--- /dev/null
+++ b/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr
@@ -0,0 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/deref-upcast-behavioral-change.rs:32:18
+   |
+LL |     let z: u32 = y;
+   |            ---   ^ expected `u32`, found `i32`
+   |            |
+   |            expected due to this
+   |
+help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit
+   |
+LL |     let z: u32 = y.try_into().unwrap();
+   |                   ++++++++++++++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.rs b/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.rs
new file mode 100644
index 00000000000..2c9126c863d
--- /dev/null
+++ b/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.rs
@@ -0,0 +1,20 @@
+// check-pass
+
+use std::ops::Deref;
+
+trait Bar<T> {}
+
+trait Foo: Bar<i32> {
+    fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar<u32> + 'a);
+}
+
+impl<'a> Deref for dyn Foo + 'a {
+    //~^ WARN this `Deref` implementation is covered by an implicit supertrait coercion
+    type Target = dyn Bar<u32> + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_dyn_bar_u32()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr b/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr
new file mode 100644
index 00000000000..a447f9cf83b
--- /dev/null
+++ b/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr
@@ -0,0 +1,14 @@
+warning: this `Deref` implementation is covered by an implicit supertrait coercion
+  --> $DIR/migrate-lint-different-substs.rs:11:1
+   |
+LL | impl<'a> Deref for dyn Foo + 'a {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo` implements `Deref<Target = dyn Bar<u32>>` which conflicts with supertrait `Bar<i32>`
+LL |
+LL |     type Target = dyn Bar<u32> + 'a;
+   |     -------------------------------- target type is a supertrait of `dyn Foo`
+   |
+   = help: consider removing this implementation or replacing it with a method instead
+   = note: `#[warn(deref_into_dyn_supertrait)]` on by default
+
+warning: 1 warning emitted
+

From 4ec68576d3c7dc797629be7c1baa5d8bc057c8d7 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 22 Nov 2023 23:28:28 +0000
Subject: [PATCH 38/71] Cache flags for ty::Const

---
 .../src/infer/canonical/canonicalizer.rs      |  8 +--
 compiler/rustc_middle/src/arena.rs            |  2 +-
 compiler/rustc_middle/src/ty/consts.rs        | 13 ++++-
 compiler/rustc_middle/src/ty/context.rs       | 52 ++++++++++++++++---
 compiler/rustc_middle/src/ty/flags.rs         | 15 ++++--
 compiler/rustc_middle/src/ty/generic_args.rs  |  4 +-
 compiler/rustc_middle/src/ty/mod.rs           |  4 +-
 compiler/rustc_middle/src/ty/visit.rs         | 25 ++++-----
 .../src/traits/query/normalize.rs             | 12 ++---
 9 files changed, 92 insertions(+), 43 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index b502590c1bf..6fbab0ef299 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -9,7 +9,6 @@ use crate::infer::canonical::{
     Canonical, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind, OriginalQueryValues,
 };
 use crate::infer::InferCtxt;
-use rustc_middle::ty::flags::FlagComputation;
 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_middle::ty::GenericArg;
 use rustc_middle::ty::{self, BoundVar, InferConst, List, Ty, TyCtxt, TypeFlags, TypeVisitableExt};
@@ -550,8 +549,11 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             _ => {}
         }
 
-        let flags = FlagComputation::for_const(ct);
-        if flags.intersects(self.needs_canonical_flags) { ct.super_fold_with(self) } else { ct }
+        if ct.flags().intersects(self.needs_canonical_flags) {
+            ct.super_fold_with(self)
+        } else {
+            ct
+        }
     }
 }
 
diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index 5735c5568f7..9b41b77928e 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -94,7 +94,7 @@ macro_rules! arena_types {
 
             // Interned types
             [] tys: rustc_type_ir::WithCachedTypeInfo<rustc_middle::ty::TyKind<'tcx>>,
-            [] consts: rustc_middle::ty::ConstData<'tcx>,
+            [] consts: rustc_type_ir::WithCachedTypeInfo<rustc_middle::ty::ConstData<'tcx>>,
 
             // Note that this deliberately duplicates items in the `rustc_hir::arena`,
             // since we need to allocate this type on both the `rustc_hir` arena
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index c46ab992359..0f5817c78e0 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -7,6 +7,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::LocalDefId;
 use rustc_macros::HashStable;
+use rustc_type_ir::{TypeFlags, WithCachedTypeInfo};
 
 mod int;
 mod kind;
@@ -23,7 +24,7 @@ use super::sty::ConstKind;
 /// Use this rather than `ConstData`, whenever possible.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)]
 #[rustc_pass_by_value]
-pub struct Const<'tcx>(pub(super) Interned<'tcx, ConstData<'tcx>>);
+pub struct Const<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<ConstData<'tcx>>>);
 
 /// Typed constant value.
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, HashStable, TyEncodable, TyDecodable)]
@@ -46,6 +47,16 @@ impl<'tcx> Const<'tcx> {
         self.0.kind.clone()
     }
 
+    #[inline]
+    pub fn flags(self) -> TypeFlags {
+        self.0.flags
+    }
+
+    #[inline]
+    pub fn outer_exclusive_binder(self) -> ty::DebruijnIndex {
+        self.0.outer_exclusive_binder
+    }
+
     #[inline]
     pub fn new(tcx: TyCtxt<'tcx>, kind: ty::ConstKind<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
         tcx.mk_ct_from_kind(kind, ty)
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 62b0536dabe..3e24b7cce86 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -151,7 +151,7 @@ pub struct CtxtInterners<'tcx> {
     clauses: InternedSet<'tcx, List<Clause<'tcx>>>,
     projs: InternedSet<'tcx, List<ProjectionKind>>,
     place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>,
-    const_: InternedSet<'tcx, ConstData<'tcx>>,
+    const_: InternedSet<'tcx, WithCachedTypeInfo<ConstData<'tcx>>>,
     const_allocation: InternedSet<'tcx, Allocation>,
     bound_variable_kinds: InternedSet<'tcx, List<ty::BoundVariableKind>>,
     layout: InternedSet<'tcx, LayoutS<FieldIdx, VariantIdx>>,
@@ -212,6 +212,32 @@ impl<'tcx> CtxtInterners<'tcx> {
         ))
     }
 
+    /// Interns a const. (Use `mk_*` functions instead, where possible.)
+    #[allow(rustc::usage_of_ty_tykind)]
+    #[inline(never)]
+    fn intern_const(
+        &self,
+        data: ty::ConstData<'tcx>,
+        sess: &Session,
+        untracked: &Untracked,
+    ) -> Const<'tcx> {
+        Const(Interned::new_unchecked(
+            self.const_
+                .intern(data, |data: ConstData<'_>| {
+                    let flags = super::flags::FlagComputation::for_const(&data.kind, data.ty);
+                    let stable_hash = self.stable_hash(&flags, sess, untracked, &data);
+
+                    InternedInSet(self.arena.alloc(WithCachedTypeInfo {
+                        internee: data,
+                        stable_hash,
+                        flags: flags.flags,
+                        outer_exclusive_binder: flags.outer_exclusive_binder,
+                    }))
+                })
+                .0,
+        ))
+    }
+
     fn stable_hash<'a, T: HashStable<StableHashingContext<'a>>>(
         &self,
         flags: &ty::flags::FlagComputation,
@@ -418,11 +444,17 @@ impl<'tcx> CommonLifetimes<'tcx> {
 }
 
 impl<'tcx> CommonConsts<'tcx> {
-    fn new(interners: &CtxtInterners<'tcx>, types: &CommonTypes<'tcx>) -> CommonConsts<'tcx> {
+    fn new(
+        interners: &CtxtInterners<'tcx>,
+        types: &CommonTypes<'tcx>,
+        sess: &Session,
+        untracked: &Untracked,
+    ) -> CommonConsts<'tcx> {
         let mk_const = |c| {
-            Const(Interned::new_unchecked(
-                interners.const_.intern(c, |c| InternedInSet(interners.arena.alloc(c))).0,
-            ))
+            interners.intern_const(
+                c, sess, // This is only used to create a stable hashing context.
+                untracked,
+            )
         };
 
         CommonConsts {
@@ -714,7 +746,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let interners = CtxtInterners::new(arena);
         let common_types = CommonTypes::new(&interners, s, &untracked);
         let common_lifetimes = CommonLifetimes::new(&interners);
-        let common_consts = CommonConsts::new(&interners, &common_types);
+        let common_consts = CommonConsts::new(&interners, &common_types, s, &untracked);
 
         GlobalCtxt {
             sess: s,
@@ -1533,7 +1565,6 @@ macro_rules! direct_interners {
 // crate only, and have a corresponding `mk_` function.
 direct_interners! {
     region: pub(crate) intern_region(RegionKind<'tcx>): Region -> Region<'tcx>,
-    const_: intern_const(ConstData<'tcx>): Const -> Const<'tcx>,
     const_allocation: pub mk_const_alloc(Allocation): ConstAllocation -> ConstAllocation<'tcx>,
     layout: pub mk_layout(LayoutS<FieldIdx, VariantIdx>): Layout -> Layout<'tcx>,
     adt_def: pub mk_adt_def_from_data(AdtDefData): AdtDef -> AdtDef<'tcx>,
@@ -1710,7 +1741,12 @@ impl<'tcx> TyCtxt<'tcx> {
 
     #[inline]
     pub fn mk_ct_from_kind(self, kind: ty::ConstKind<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
-        self.intern_const(ty::ConstData { kind, ty })
+        self.interners.intern_const(
+            ty::ConstData { kind, ty },
+            self.sess,
+            // This is only used to create a stable hashing context.
+            &self.untracked,
+        )
     }
 
     // Avoid this in favour of more specific `Ty::new_*` methods, where possible.
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index 4d7b12662c6..de829f7f977 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -28,10 +28,11 @@ impl FlagComputation {
         result
     }
 
-    pub fn for_const(c: ty::Const<'_>) -> TypeFlags {
+    pub fn for_const(c: &ty::ConstKind<'_>, t: Ty<'_>) -> FlagComputation {
         let mut result = FlagComputation::new();
-        result.add_const(c);
-        result.flags
+        result.add_const_kind(c);
+        result.add_ty(t);
+        result
     }
 
     fn add_flags(&mut self, flags: TypeFlags) {
@@ -300,8 +301,12 @@ impl FlagComputation {
     }
 
     fn add_const(&mut self, c: ty::Const<'_>) {
-        self.add_ty(c.ty());
-        match c.kind() {
+        self.add_flags(c.flags());
+        self.add_exclusive_binder(c.outer_exclusive_binder());
+    }
+
+    fn add_const_kind(&mut self, c: &ty::ConstKind<'_>) {
+        match *c {
             ty::ConstKind::Unevaluated(uv) => {
                 self.add_args(uv.args);
                 self.add_flags(TypeFlags::HAS_CT_PROJECTION);
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
index 0c658fa1c80..c1063d6a5f0 100644
--- a/compiler/rustc_middle/src/ty/generic_args.rs
+++ b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -70,7 +70,7 @@ impl<'tcx> GenericArgKind<'tcx> {
             GenericArgKind::Const(ct) => {
                 // Ensure we can use the tag bits.
                 assert_eq!(mem::align_of_val(&*ct.0.0) & TAG_MASK, 0);
-                (CONST_TAG, ct.0.0 as *const ty::ConstData<'tcx> as usize)
+                (CONST_TAG, ct.0.0 as *const WithCachedTypeInfo<ty::ConstData<'tcx>> as usize)
             }
         };
 
@@ -136,7 +136,7 @@ impl<'tcx> GenericArg<'tcx> {
                     &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo<ty::TyKind<'tcx>>),
                 ))),
                 CONST_TAG => GenericArgKind::Const(ty::Const(Interned::new_unchecked(
-                    &*((ptr & !TAG_MASK) as *const ty::ConstData<'tcx>),
+                    &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo<ty::ConstData<'tcx>>),
                 ))),
                 _ => intrinsics::unreachable(),
             }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 1d7abcf53ea..0f34de2c09d 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -901,7 +901,7 @@ impl<'tcx> Term<'tcx> {
                     &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo<ty::TyKind<'tcx>>),
                 ))),
                 CONST_TAG => TermKind::Const(ty::Const(Interned::new_unchecked(
-                    &*((ptr & !TAG_MASK) as *const ty::ConstData<'tcx>),
+                    &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo<ty::ConstData<'tcx>>),
                 ))),
                 _ => core::intrinsics::unreachable(),
             }
@@ -968,7 +968,7 @@ impl<'tcx> TermKind<'tcx> {
             TermKind::Const(ct) => {
                 // Ensure we can use the tag bits.
                 assert_eq!(mem::align_of_val(&*ct.0.0) & TAG_MASK, 0);
-                (CONST_TAG, ct.0.0 as *const ty::ConstData<'tcx> as usize)
+                (CONST_TAG, ct.0.0 as *const WithCachedTypeInfo<ty::ConstData<'tcx>> as usize)
             }
         };
 
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
index f14232d3435..e1ce941256c 100644
--- a/compiler/rustc_middle/src/ty/visit.rs
+++ b/compiler/rustc_middle/src/ty/visit.rs
@@ -1,4 +1,4 @@
-use crate::ty::{self, flags::FlagComputation, Binder, Ty, TyCtxt, TypeFlags};
+use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags};
 use rustc_errors::ErrorGuaranteed;
 
 use rustc_data_structures::fx::FxHashSet;
@@ -440,16 +440,15 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HasEscapingVarsVisitor {
     }
 
     fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
-        // we don't have a `visit_infer_const` callback, so we have to
-        // hook in here to catch this case (annoying...), but
-        // otherwise we do want to remember to visit the rest of the
-        // const, as it has types/regions embedded in a lot of other
-        // places.
-        match ct.kind() {
-            ty::ConstKind::Bound(debruijn, _) if debruijn >= self.outer_index => {
-                ControlFlow::Break(FoundEscapingVars)
-            }
-            _ => ct.super_visit_with(self),
+        // If the outer-exclusive-binder is *strictly greater* than
+        // `outer_index`, that means that `ct` contains some content
+        // bound at `outer_index` or above (because
+        // `outer_exclusive_binder` is always 1 higher than the
+        // content in `t`). Therefore, `t` has some escaping vars.
+        if ct.outer_exclusive_binder() > self.outer_index {
+            ControlFlow::Break(FoundEscapingVars)
+        } else {
+            ControlFlow::Continue(())
         }
     }
 
@@ -529,9 +528,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HasTypeFlagsVisitor {
     #[inline]
     fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
         // Note: no `super_visit_with` call.
-        let flags = FlagComputation::for_const(c);
-        trace!(r.flags=?flags);
-        if flags.intersects(self.flags) {
+        if c.flags().intersects(self.flags) {
             ControlFlow::Break(FoundFlags)
         } else {
             ControlFlow::Continue(())
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
index dba00ce0154..8faaa6be9f5 100644
--- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -160,14 +160,12 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxEscapingBoundVarVisitor {
     }
 
     fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
-        match ct.kind() {
-            ty::ConstKind::Bound(debruijn, _) if debruijn >= self.outer_index => {
-                self.escaping =
-                    self.escaping.max(debruijn.as_usize() - self.outer_index.as_usize());
-                ControlFlow::Continue(())
-            }
-            _ => ct.super_visit_with(self),
+        if ct.outer_exclusive_binder() > self.outer_index {
+            self.escaping = self
+                .escaping
+                .max(ct.outer_exclusive_binder().as_usize() - self.outer_index.as_usize());
         }
+        ControlFlow::Continue(())
     }
 }
 

From c238e875734143c829f6294b4e86e14795922c47 Mon Sep 17 00:00:00 2001
From: SparrowLii <liyuan179@huawei.com>
Date: Thu, 23 Nov 2023 10:35:33 +0800
Subject: [PATCH 39/71] Nit of deadlock detected

---
 compiler/rustc_query_system/src/query/job.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs
index 726bda76b01..b38d71733b5 100644
--- a/compiler/rustc_query_system/src/query/job.rs
+++ b/compiler/rustc_query_system/src/query/job.rs
@@ -545,7 +545,7 @@ pub fn deadlock(query_map: QueryMap, registry: &rayon_core::Registry) {
         if query_map.len() == 0 {
             panic!("deadlock detected without any query!")
         } else {
-            panic!("deadlock detected! current query map:\n{:?}", query_map);
+            panic!("deadlock detected! current query map:\n{:#?}", query_map);
         }
     }
 

From f5dae8e73c3449d76311781ba86aa82034fb5296 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 19 Nov 2023 16:17:48 -0500
Subject: [PATCH 40/71] Miri: GC the dead_alloc_map too

---
 compiler/rustc_const_eval/src/interpret/memory.rs | 11 +++++++++++
 src/tools/miri/src/provenance_gc.rs               |  3 ++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index d5b165a7415..1c1fd2a71ba 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -501,6 +501,17 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     }
 }
 
+impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
+    /// This function is used by Miri's provenance GC to remove unreachable entries from the dead_alloc_map.
+    pub fn remove_unreachable_allocs(&mut self, reachable_allocs: &FxHashSet<AllocId>) {
+        // Unlike all the other GC helpers where we check if an `AllocId` is found in the interpreter or
+        // is live, here all the IDs in the map are for dead allocations so we don't
+        // need to check for liveness.
+        #[allow(rustc::potential_query_instability)] // Only used from Miri, not queries.
+        self.memory.dead_alloc_map.retain(|id, _| reachable_allocs.contains(id));
+    }
+}
+
 /// Allocation accessors
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// Helper function to obtain a global (tcx) allocation.
diff --git a/src/tools/miri/src/provenance_gc.rs b/src/tools/miri/src/provenance_gc.rs
index eac4aad27a0..ef6d49f041f 100644
--- a/src/tools/miri/src/provenance_gc.rs
+++ b/src/tools/miri/src/provenance_gc.rs
@@ -195,7 +195,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriInterpCxExt<'mir, 'tcx> {
     }
 
     fn remove_unreachable_allocs(&mut self, allocs: FxHashSet<AllocId>) {
-        let this = self.eval_context_ref();
+        let this = self.eval_context_mut();
         let allocs = LiveAllocs {
             ecx: this,
             collected: allocs,
@@ -205,5 +205,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriInterpCxExt<'mir, 'tcx> {
         if let Some(borrow_tracker) = &this.machine.borrow_tracker {
             borrow_tracker.borrow_mut().remove_unreachable_allocs(&allocs);
         }
+        this.remove_unreachable_allocs(&allocs.collected);
     }
 }

From 2e7d684820bf3204b2c938d313aeb9e5b97ba800 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 11 Oct 2023 21:26:14 +0200
Subject: [PATCH 41/71] Add LLD flags to rustdoc cargo invocations

---
 src/bootstrap/src/core/build_steps/test.rs | 23 +++++----
 src/bootstrap/src/core/builder.rs          |  7 ++-
 src/bootstrap/src/utils/helpers.rs         | 54 +++++++++++++++++++---
 3 files changed, 64 insertions(+), 20 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index dc9b56f30db..4e7aeabd06b 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -29,8 +29,8 @@ use crate::utils;
 use crate::utils::cache::{Interned, INTERNER};
 use crate::utils::exec::BootstrapCommand;
 use crate::utils::helpers::{
-    self, add_link_lib_path, add_rustdoc_lld_flags, dylib_path, dylib_path_var, output, t,
-    target_supports_cranelift_backend, up_to_date,
+    self, add_link_lib_path, add_rustdoc_cargo_lld_flags, add_rustdoc_lld_flags, dylib_path,
+    dylib_path_var, output, t, target_supports_cranelift_backend, up_to_date, LldThreads,
 };
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
 use crate::{envify, CLang, DocTests, GitRepo, Mode};
@@ -271,13 +271,14 @@ impl Step for Cargotest {
 
         let _time = helpers::timeit(&builder);
         let mut cmd = builder.tool_cmd(Tool::CargoTest);
-        builder.run_delaying_failure(
-            cmd.arg(&cargo)
-                .arg(&out_dir)
-                .args(builder.config.test_args())
-                .env("RUSTC", builder.rustc(compiler))
-                .env("RUSTDOC", builder.rustdoc(compiler)),
-        );
+        let mut cmd = cmd
+            .arg(&cargo)
+            .arg(&out_dir)
+            .args(builder.config.test_args())
+            .env("RUSTC", builder.rustc(compiler))
+            .env("RUSTDOC", builder.rustdoc(compiler));
+        add_rustdoc_cargo_lld_flags(&mut cmd, builder, compiler.host, LldThreads::No);
+        builder.run_delaying_failure(cmd);
     }
 }
 
@@ -862,7 +863,7 @@ impl Step for RustdocTheme {
             .env("CFG_RELEASE_CHANNEL", &builder.config.channel)
             .env("RUSTDOC_REAL", builder.rustdoc(self.compiler))
             .env("RUSTC_BOOTSTRAP", "1");
-        add_rustdoc_lld_flags(&mut cmd, builder, self.compiler.host, true);
+        add_rustdoc_lld_flags(&mut cmd, builder, self.compiler.host, LldThreads::No);
 
         builder.run_delaying_failure(&mut cmd);
     }
@@ -1037,6 +1038,8 @@ impl Step for RustdocGUI {
         cmd.env("RUSTDOC", builder.rustdoc(self.compiler))
             .env("RUSTC", builder.rustc(self.compiler));
 
+        add_rustdoc_cargo_lld_flags(&mut cmd, builder, self.compiler.host, LldThreads::No);
+
         for path in &builder.paths {
             if let Some(p) = helpers::is_valid_test_suite_arg(path, "tests/rustdoc-gui", builder) {
                 if !p.ends_with(".goml") {
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 301d3dfe299..15097825d4d 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -18,9 +18,8 @@ use crate::core::build_steps::{check, clean, compile, dist, doc, install, run, s
 use crate::core::config::flags::{Color, Subcommand};
 use crate::core::config::{DryRun, SplitDebuginfo, TargetSelection};
 use crate::utils::cache::{Cache, Interned, INTERNER};
-use crate::utils::helpers::{
-    self, add_dylib_path, add_link_lib_path, add_rustdoc_lld_flags, exe, libdir, output, t,
-};
+use crate::utils::helpers::{self, add_dylib_path, add_link_lib_path, add_rustdoc_lld_flags, exe};
+use crate::utils::helpers::{libdir, output, t, LldThreads};
 use crate::Crate;
 use crate::EXTRA_CHECK_CFGS;
 use crate::{Build, CLang, DocTests, GitRepo, Mode};
@@ -1175,7 +1174,7 @@ impl<'a> Builder<'a> {
         cmd.env_remove("MAKEFLAGS");
         cmd.env_remove("MFLAGS");
 
-        add_rustdoc_lld_flags(&mut cmd, self, compiler.host, false);
+        add_rustdoc_lld_flags(&mut cmd, self, compiler.host, LldThreads::Yes);
         cmd
     }
 
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index c53cc626b97..89fa2b805cd 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -5,6 +5,7 @@
 
 use build_helper::util::fail;
 use std::env;
+use std::ffi::{OsStr, OsString};
 use std::fs;
 use std::io;
 use std::path::{Path, PathBuf};
@@ -377,7 +378,6 @@ fn absolute_unix(path: &Path) -> io::Result<PathBuf> {
 
 #[cfg(windows)]
 fn absolute_windows(path: &std::path::Path) -> std::io::Result<std::path::PathBuf> {
-    use std::ffi::OsString;
     use std::io::Error;
     use std::os::windows::ffi::{OsStrExt, OsStringExt};
     use std::ptr::null_mut;
@@ -471,21 +471,63 @@ pub fn extract_beta_rev(version: &str) -> Option<String> {
     count
 }
 
+pub enum LldThreads {
+    Yes,
+    No,
+}
+
 pub fn add_rustdoc_lld_flags(
     cmd: &mut Command,
     builder: &Builder<'_>,
     target: TargetSelection,
-    single_threaded: bool,
+    lld_threads: LldThreads,
 ) {
+    cmd.args(build_rustdoc_lld_flags(builder, target, lld_threads));
+}
+
+pub fn add_rustdoc_cargo_lld_flags(
+    cmd: &mut Command,
+    builder: &Builder<'_>,
+    target: TargetSelection,
+    lld_threads: LldThreads,
+) {
+    let args = build_rustdoc_lld_flags(builder, target, lld_threads);
+    let mut flags = cmd
+        .get_envs()
+        .find_map(|(k, v)| if k == OsStr::new("RUSTDOCFLAGS") { v } else { None })
+        .unwrap_or_default()
+        .to_os_string();
+    for arg in args {
+        if !flags.is_empty() {
+            flags.push(" ");
+        }
+        flags.push(arg);
+    }
+    if !flags.is_empty() {
+        cmd.env("RUSTDOCFLAGS", flags);
+    }
+}
+
+fn build_rustdoc_lld_flags(
+    builder: &Builder<'_>,
+    target: TargetSelection,
+    lld_threads: LldThreads,
+) -> Vec<OsString> {
+    let mut args = vec![];
+
     if let Some(linker) = builder.linker(target) {
         let mut flag = std::ffi::OsString::from("-Clinker=");
         flag.push(linker);
-        cmd.arg(flag);
+        args.push(flag);
     }
     if builder.is_fuse_ld_lld(target) {
-        cmd.arg("-Clink-arg=-fuse-ld=lld");
-        if single_threaded {
-            cmd.arg(format!("-Clink-arg=-Wl,{}", lld_flag_no_threads(target.contains("windows"))));
+        args.push(OsString::from("-Clink-arg=-fuse-ld=lld"));
+        if matches!(lld_threads, LldThreads::No) {
+            args.push(OsString::from(format!(
+                "-Clink-arg=-Wl,{}",
+                lld_flag_no_threads(target.contains("windows"))
+            )));
         }
     }
+    args
 }

From 806b2b25539168c1b3fc6414071afa1f99f6a2c9 Mon Sep 17 00:00:00 2001
From: Charles Lew <crlf0710@gmail.com>
Date: Thu, 23 Nov 2023 18:55:11 +0800
Subject: [PATCH 42/71] Bump `unicase` crate version.

---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8c9b12028f0..3af057f5e3d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5767,9 +5767,9 @@ dependencies = [
 
 [[package]]
 name = "unicase"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
 dependencies = [
  "version_check",
 ]

From c710db8ea7fb59ef90d854d2e1a5d9d93464b074 Mon Sep 17 00:00:00 2001
From: Young-Flash <871946895@qq.com>
Date: Thu, 23 Nov 2023 20:22:17 +0800
Subject: [PATCH 43/71] feat: make let_binding_suggestion more reasonable

---
 .../rustc_resolve/src/late/diagnostics.rs     | 15 +++++--
 .../suggest-let-for-assignment.fixed          |  6 +++
 .../suggestions/suggest-let-for-assignment.rs |  6 +++
 .../suggest-let-for-assignment.stderr         | 42 +++++++++++++++++--
 4 files changed, 62 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index fd5d6fabf02..d078cbefde9 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -1966,13 +1966,22 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
     fn let_binding_suggestion(&mut self, err: &mut Diagnostic, ident_span: Span) -> bool {
         if let Some(Expr { kind: ExprKind::Assign(lhs, ..), .. }) =
             self.diagnostic_metadata.in_assignment
-            && let ast::ExprKind::Path(None, _) = lhs.kind
+            && let ast::ExprKind::Path(None, ref path) = lhs.kind
         {
             if !ident_span.from_expansion() {
+                let (span, text) = match path.segments.first() {
+                    Some(seg) if let Some(name) = seg.ident.as_str().strip_prefix("let") => {
+                        // a special case for #117894
+                        let name = name.strip_prefix("_").unwrap_or(name);
+                        (ident_span, format!("let {name}"))
+                    }
+                    _ => (ident_span.shrink_to_lo(), "let ".to_string()),
+                };
+
                 err.span_suggestion_verbose(
-                    ident_span.shrink_to_lo(),
+                    span,
                     "you might have meant to introduce a new binding",
-                    "let ".to_string(),
+                    text,
                     Applicability::MaybeIncorrect,
                 );
                 return true;
diff --git a/tests/ui/suggestions/suggest-let-for-assignment.fixed b/tests/ui/suggestions/suggest-let-for-assignment.fixed
index 3a25e25eede..76dc1dad80a 100644
--- a/tests/ui/suggestions/suggest-let-for-assignment.fixed
+++ b/tests/ui/suggestions/suggest-let-for-assignment.fixed
@@ -7,6 +7,12 @@ fn main() {
     let x = "x"; //~ ERROR cannot find value `x` in this scope
     println!("x: {}", x); //~ ERROR cannot find value `x` in this scope
 
+    let some_variable = 6; //~ cannot find value `let_some_variable` in this scope
+    println!("some_variable: {}", some_variable); //~ ERROR cannot find value `some_variable` in this scope
+
+    let other_variable = 6; //~ cannot find value `letother_variable` in this scope
+    println!("other_variable: {}", other_variable); //~ ERROR cannot find value `other_variable` in this scope
+
     if x == "x" {
         //~^ ERROR cannot find value `x` in this scope
         println!("x is 1");
diff --git a/tests/ui/suggestions/suggest-let-for-assignment.rs b/tests/ui/suggestions/suggest-let-for-assignment.rs
index 67705fe063a..f1edf65a726 100644
--- a/tests/ui/suggestions/suggest-let-for-assignment.rs
+++ b/tests/ui/suggestions/suggest-let-for-assignment.rs
@@ -7,6 +7,12 @@ fn main() {
     x = "x"; //~ ERROR cannot find value `x` in this scope
     println!("x: {}", x); //~ ERROR cannot find value `x` in this scope
 
+    let_some_variable = 6; //~ cannot find value `let_some_variable` in this scope
+    println!("some_variable: {}", some_variable); //~ ERROR cannot find value `some_variable` in this scope
+
+    letother_variable = 6; //~ cannot find value `letother_variable` in this scope
+    println!("other_variable: {}", other_variable); //~ ERROR cannot find value `other_variable` in this scope
+
     if x == "x" {
         //~^ ERROR cannot find value `x` in this scope
         println!("x is 1");
diff --git a/tests/ui/suggestions/suggest-let-for-assignment.stderr b/tests/ui/suggestions/suggest-let-for-assignment.stderr
index 3f6a3da4be2..8d97dbeb14a 100644
--- a/tests/ui/suggestions/suggest-let-for-assignment.stderr
+++ b/tests/ui/suggestions/suggest-let-for-assignment.stderr
@@ -32,14 +32,48 @@ error[E0425]: cannot find value `x` in this scope
 LL |     println!("x: {}", x);
    |                       ^ not found in this scope
 
+error[E0425]: cannot find value `let_some_variable` in this scope
+  --> $DIR/suggest-let-for-assignment.rs:10:5
+   |
+LL |     let_some_variable = 6;
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: you might have meant to introduce a new binding
+   |
+LL |     let some_variable = 6;
+   |     ~~~~~~~~~~~~~~~~~
+
+error[E0425]: cannot find value `some_variable` in this scope
+  --> $DIR/suggest-let-for-assignment.rs:11:35
+   |
+LL |     println!("some_variable: {}", some_variable);
+   |                                   ^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find value `letother_variable` in this scope
+  --> $DIR/suggest-let-for-assignment.rs:13:5
+   |
+LL |     letother_variable = 6;
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: you might have meant to introduce a new binding
+   |
+LL |     let other_variable = 6;
+   |     ~~~~~~~~~~~~~~~~~~
+
+error[E0425]: cannot find value `other_variable` in this scope
+  --> $DIR/suggest-let-for-assignment.rs:14:36
+   |
+LL |     println!("other_variable: {}", other_variable);
+   |                                    ^^^^^^^^^^^^^^ not found in this scope
+
 error[E0425]: cannot find value `x` in this scope
-  --> $DIR/suggest-let-for-assignment.rs:10:8
+  --> $DIR/suggest-let-for-assignment.rs:16:8
    |
 LL |     if x == "x" {
    |        ^ not found in this scope
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/suggest-let-for-assignment.rs:15:5
+  --> $DIR/suggest-let-for-assignment.rs:21:5
    |
 LL |     y = 1 + 2;
    |     ^
@@ -50,11 +84,11 @@ LL |     let y = 1 + 2;
    |     +++
 
 error[E0425]: cannot find value `y` in this scope
-  --> $DIR/suggest-let-for-assignment.rs:16:23
+  --> $DIR/suggest-let-for-assignment.rs:22:23
    |
 LL |     println!("y: {}", y);
    |                       ^ not found in this scope
 
-error: aborting due to 7 previous errors
+error: aborting due to 11 previous errors
 
 For more information about this error, try `rustc --explain E0425`.

From d51ef5c1afc6491d9c224e12cc5c1e72a58bf81a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 23 Nov 2023 12:25:41 +0000
Subject: [PATCH 44/71] fix intercrate ambiguity causes

---
 .../src/traits/coherence.rs                   |  6 ++--
 .../{E0476.stderr => E0476.next.stderr}       |  8 ++---
 tests/ui/error-codes/E0476.old.stderr         | 31 +++++++++++++++++++
 tests/ui/error-codes/E0476.rs                 |  2 ++
 4 files changed, 41 insertions(+), 6 deletions(-)
 rename tests/ui/error-codes/{E0476.stderr => E0476.next.stderr} (92%)
 create mode 100644 tests/ui/error-codes/E0476.old.stderr

diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
index 9119792e324..f3993ec2566 100644
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -1050,8 +1050,10 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a> {
         let mut ambiguity_cause = None;
         for cand in goal.candidates() {
             // FIXME: boiiii, using string comparisions here sure is scuffed.
-            if let inspect::ProbeKind::MiscCandidate { name: "coherence unknowable", result: _ } =
-                cand.kind()
+            if let inspect::ProbeKind::MiscCandidate {
+                name: "coherence unknowable",
+                result: Ok(_),
+            } = cand.kind()
             {
                 let lazily_normalize_ty = |ty: Ty<'tcx>| {
                     let mut fulfill_cx = <dyn TraitEngine<'tcx>>::new(infcx);
diff --git a/tests/ui/error-codes/E0476.stderr b/tests/ui/error-codes/E0476.next.stderr
similarity index 92%
rename from tests/ui/error-codes/E0476.stderr
rename to tests/ui/error-codes/E0476.next.stderr
index 0378ac6e8ec..454dbecc7d0 100644
--- a/tests/ui/error-codes/E0476.stderr
+++ b/tests/ui/error-codes/E0476.next.stderr
@@ -1,5 +1,5 @@
 error[E0119]: conflicting implementations of trait `CoerceUnsized<&Wrapper<_>>` for type `&Wrapper<_>`
-  --> $DIR/E0476.rs:9:1
+  --> $DIR/E0476.rs:11:1
    |
 LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,18 +9,18 @@ LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S
              where 'b: 'a, T: Unsize<U>, T: ?Sized, U: ?Sized;
 
 error[E0476]: lifetime of the source pointer does not outlive lifetime bound of the object type
-  --> $DIR/E0476.rs:9:1
+  --> $DIR/E0476.rs:11:1
    |
 LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: object type is valid for the lifetime `'a` as defined here
-  --> $DIR/E0476.rs:9:6
+  --> $DIR/E0476.rs:11:6
    |
 LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
    |      ^^
 note: source pointer is only valid for the lifetime `'b` as defined here
-  --> $DIR/E0476.rs:9:10
+  --> $DIR/E0476.rs:11:10
    |
 LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
    |          ^^
diff --git a/tests/ui/error-codes/E0476.old.stderr b/tests/ui/error-codes/E0476.old.stderr
new file mode 100644
index 00000000000..454dbecc7d0
--- /dev/null
+++ b/tests/ui/error-codes/E0476.old.stderr
@@ -0,0 +1,31 @@
+error[E0119]: conflicting implementations of trait `CoerceUnsized<&Wrapper<_>>` for type `&Wrapper<_>`
+  --> $DIR/E0476.rs:11:1
+   |
+LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: conflicting implementation in crate `core`:
+           - impl<'a, 'b, T, U> CoerceUnsized<&'a U> for &'b T
+             where 'b: 'a, T: Unsize<U>, T: ?Sized, U: ?Sized;
+
+error[E0476]: lifetime of the source pointer does not outlive lifetime bound of the object type
+  --> $DIR/E0476.rs:11:1
+   |
+LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: object type is valid for the lifetime `'a` as defined here
+  --> $DIR/E0476.rs:11:6
+   |
+LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
+   |      ^^
+note: source pointer is only valid for the lifetime `'b` as defined here
+  --> $DIR/E0476.rs:11:10
+   |
+LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper<T>> for &'b Wrapper<S> where S: Unsize<T> {}
+   |          ^^
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0119, E0476.
+For more information about an error, try `rustc --explain E0119`.
diff --git a/tests/ui/error-codes/E0476.rs b/tests/ui/error-codes/E0476.rs
index d5e4b8d2372..e9afc756726 100644
--- a/tests/ui/error-codes/E0476.rs
+++ b/tests/ui/error-codes/E0476.rs
@@ -1,3 +1,5 @@
+// revisions: old next
+//[next] compile-flags: -Ztrait-solver=next-coherence
 #![feature(coerce_unsized)]
 #![feature(unsize)]
 

From edf6c9c223d465b730e3f1baa45316053e74618b Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Thu, 16 Nov 2023 19:08:30 +0300
Subject: [PATCH 45/71] Add an experimental feature gate for function
 delegation

In accordance with the [process](https://github.com/rust-lang/lang-team/blob/master/src/how_to/experiment.md).

Detailed description of the feature can be found in the RFC repo - https://github.com/rust-lang/rfcs/pull/3530.
---
 compiler/rustc_feature/src/unstable.rs              |  2 ++
 compiler/rustc_span/src/symbol.rs                   |  1 +
 .../ui/feature-gates/feature-gate-fn_delegation.rs  |  3 +++
 .../feature-gates/feature-gate-fn_delegation.stderr | 13 +++++++++++++
 4 files changed, 19 insertions(+)
 create mode 100644 tests/ui/feature-gates/feature-gate-fn_delegation.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-fn_delegation.stderr

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 35726ba52bc..e34661d5fc6 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -456,6 +456,8 @@ declare_features! (
     (unstable, ffi_returns_twice, "1.34.0", Some(58314), None),
     /// Allows using `#[repr(align(...))]` on function items
     (unstable, fn_align, "1.53.0", Some(82232), None),
+    /// Support delegating implementation of functions to other already implemented functions.
+    (incomplete, fn_delegation, "CURRENT_RUSTC_VERSION", Some(118212), None),
     /// Allows defining gen blocks and `gen fn`.
     (unstable, gen_blocks, "1.75.0", Some(117078), None),
     /// Infer generic args for both consts and types.
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index ea80bc82bd1..40b03874242 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -787,6 +787,7 @@ symbols! {
         fmt,
         fmul_fast,
         fn_align,
+        fn_delegation,
         fn_must_use,
         fn_mut,
         fn_once,
diff --git a/tests/ui/feature-gates/feature-gate-fn_delegation.rs b/tests/ui/feature-gates/feature-gate-fn_delegation.rs
new file mode 100644
index 00000000000..6ac36712090
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-fn_delegation.rs
@@ -0,0 +1,3 @@
+todo!(); //~ ERROR
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-fn_delegation.stderr b/tests/ui/feature-gates/feature-gate-fn_delegation.stderr
new file mode 100644
index 00000000000..1f55c1f250a
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-fn_delegation.stderr
@@ -0,0 +1,13 @@
+error: expected one of `!` or `::`, found `(`
+  --> $DIR/feature-gate-fn_delegation.rs:1:1
+   |
+LL | todo!();
+   | ^^^^^^^
+   | |
+   | expected one of `!` or `::`
+   | in this macro invocation
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to previous error
+

From a21d7713db7c19d126cc4dd38abd56ed73bdb729 Mon Sep 17 00:00:00 2001
From: Kyuuhachi <caagr98@gmail.com>
Date: Thu, 23 Nov 2023 01:56:09 +0100
Subject: [PATCH 46/71] Don't print "private fields" on empty tuple structs

Test for presence rather than absence

Remove redundant tests

Issues in those parts will likely be caught by other parts of the test suite.
---
 src/librustdoc/html/render/print_item.rs         | 14 +++++++++-----
 tests/rustdoc/issue-118180-empty-tuple-struct.rs |  9 +++++++++
 2 files changed, 18 insertions(+), 5 deletions(-)
 create mode 100644 tests/rustdoc/issue-118180-empty-tuple-struct.rs

diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 8fdbef65135..927bec4251e 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1501,8 +1501,10 @@ fn print_tuple_struct_fields<'a, 'cx: 'a>(
     s: &'a [clean::Item],
 ) -> impl fmt::Display + 'a + Captures<'cx> {
     display_fn(|f| {
-        if s.iter()
-            .all(|field| matches!(*field.kind, clean::StrippedItem(box clean::StructFieldItem(..))))
+        if !s.is_empty()
+            && s.iter().all(|field| {
+                matches!(*field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
+            })
         {
             return f.write_str("/* private fields */");
         }
@@ -2275,9 +2277,11 @@ fn render_struct_fields(
         }
         Some(CtorKind::Fn) => {
             w.write_str("(");
-            if fields.iter().all(|field| {
-                matches!(*field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
-            }) {
+            if !fields.is_empty()
+                && fields.iter().all(|field| {
+                    matches!(*field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
+                })
+            {
                 write!(w, "/* private fields */");
             } else {
                 for (i, field) in fields.iter().enumerate() {
diff --git a/tests/rustdoc/issue-118180-empty-tuple-struct.rs b/tests/rustdoc/issue-118180-empty-tuple-struct.rs
new file mode 100644
index 00000000000..bc6ddbe5def
--- /dev/null
+++ b/tests/rustdoc/issue-118180-empty-tuple-struct.rs
@@ -0,0 +1,9 @@
+// @has issue_118180_empty_tuple_struct/enum.Enum.html
+pub enum Enum {
+    // @has - '//*[@id="variant.Empty"]//h3' 'Empty()'
+    Empty(),
+}
+
+// @has issue_118180_empty_tuple_struct/struct.Empty.html
+// @has - '//pre/code' 'Empty()'
+pub struct Empty();

From 52c07b9564654603af8972e93682fe887126d090 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 23 Nov 2023 11:16:10 -0800
Subject: [PATCH 47/71] Fix tracking issue of Windows ExitCodeExt

---
 library/std/src/os/windows/process.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/os/windows/process.rs b/library/std/src/os/windows/process.rs
index d00e79476f3..5bf0154eae3 100644
--- a/library/std/src/os/windows/process.rs
+++ b/library/std/src/os/windows/process.rs
@@ -347,7 +347,7 @@ impl ChildExt for process::Child {
 ///
 /// This trait is sealed: it cannot be implemented outside the standard library.
 /// This is so that future additional methods are not breaking changes.
-#[unstable(feature = "windows_process_exit_code_from", issue = "none")]
+#[unstable(feature = "windows_process_exit_code_from", issue = "111688")]
 pub trait ExitCodeExt: Sealed {
     /// Creates a new `ExitCode` from the raw underlying `u32` return value of
     /// a process.
@@ -355,11 +355,11 @@ pub trait ExitCodeExt: Sealed {
     /// The exit code should not be 259, as this conflicts with the `STILL_ACTIVE`
     /// macro returned from the `GetExitCodeProcess` function to signal that the
     /// process has yet to run to completion.
-    #[unstable(feature = "windows_process_exit_code_from", issue = "none")]
+    #[unstable(feature = "windows_process_exit_code_from", issue = "111688")]
     fn from_raw(raw: u32) -> Self;
 }
 
-#[unstable(feature = "windows_process_exit_code_from", issue = "none")]
+#[unstable(feature = "windows_process_exit_code_from", issue = "111688")]
 impl ExitCodeExt for process::ExitCode {
     fn from_raw(raw: u32) -> Self {
         process::ExitCode::from_inner(From::from(raw))

From b7bc8d5cb7685bd8e35d7b1c9d3011b043abf775 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 23 Nov 2023 20:02:45 +0000
Subject: [PATCH 48/71] Fix fn_sig_for_fn_abi and the coroutine transform for
 generators

There were three issues previously:
* The self argument was pinned, despite Iterator::next taking an
  unpinned mutable reference.
* A resume argument was passed, despite Iterator::next not having one.
* The return value was CoroutineState<Item, ()> rather than Option<Item>

While these things just so happened to work with the LLVM backend,
cg_clif does much stricter checks when trying to assign a value to a
place. In addition it can't handle the mismatch between the amount of
arguments specified by the FnAbi and the FnSig.
---
 .../build_system/tests.rs                     |  9 ++++
 compiler/rustc_codegen_cranelift/config.txt   |  1 +
 .../example/gen_block_iterate.rs              | 36 +++++++++++++
 compiler/rustc_codegen_cranelift/rustfmt.toml |  5 +-
 compiler/rustc_mir_transform/src/coroutine.rs | 32 ++++++++++-
 compiler/rustc_ty_utils/src/abi.rs            | 54 ++++++++++++++++---
 rustfmt.toml                                  |  1 +
 7 files changed, 129 insertions(+), 9 deletions(-)
 create mode 100644 compiler/rustc_codegen_cranelift/example/gen_block_iterate.rs

diff --git a/compiler/rustc_codegen_cranelift/build_system/tests.rs b/compiler/rustc_codegen_cranelift/build_system/tests.rs
index ff71a567ed3..aa50dbfdf35 100644
--- a/compiler/rustc_codegen_cranelift/build_system/tests.rs
+++ b/compiler/rustc_codegen_cranelift/build_system/tests.rs
@@ -100,6 +100,15 @@ const BASE_SYSROOT_SUITE: &[TestCase] = &[
     TestCase::build_bin_and_run("aot.issue-72793", "example/issue-72793.rs", &[]),
     TestCase::build_bin("aot.issue-59326", "example/issue-59326.rs"),
     TestCase::build_bin_and_run("aot.neon", "example/neon.rs", &[]),
+    TestCase::custom("aot.gen_block_iterate", &|runner| {
+        runner.run_rustc([
+            "example/gen_block_iterate.rs",
+            "--edition",
+            "2024",
+            "-Zunstable-options",
+        ]);
+        runner.run_out_command("gen_block_iterate", &[]);
+    }),
 ];
 
 pub(crate) static RAND_REPO: GitRepo = GitRepo::github(
diff --git a/compiler/rustc_codegen_cranelift/config.txt b/compiler/rustc_codegen_cranelift/config.txt
index 2ccdc7d7874..3cf295c003e 100644
--- a/compiler/rustc_codegen_cranelift/config.txt
+++ b/compiler/rustc_codegen_cranelift/config.txt
@@ -43,6 +43,7 @@ aot.mod_bench
 aot.issue-72793
 aot.issue-59326
 aot.neon
+aot.gen_block_iterate
 
 testsuite.extended_sysroot
 test.rust-random/rand
diff --git a/compiler/rustc_codegen_cranelift/example/gen_block_iterate.rs b/compiler/rustc_codegen_cranelift/example/gen_block_iterate.rs
new file mode 100644
index 00000000000..14bd23e77ea
--- /dev/null
+++ b/compiler/rustc_codegen_cranelift/example/gen_block_iterate.rs
@@ -0,0 +1,36 @@
+// Copied from https://github.com/rust-lang/rust/blob/46455dc65069387f2dc46612f13fd45452ab301a/tests/ui/coroutine/gen_block_iterate.rs
+// revisions: next old
+//compile-flags: --edition 2024 -Zunstable-options
+//[next] compile-flags: -Ztrait-solver=next
+// run-pass
+#![feature(gen_blocks)]
+
+fn foo() -> impl Iterator<Item = u32> {
+    gen { yield 42; for x in 3..6 { yield x } }
+}
+
+fn moved() -> impl Iterator<Item = u32> {
+    let mut x = "foo".to_string();
+    gen move {
+        yield 42;
+        if x == "foo" { return }
+        x.clear();
+        for x in 3..6 { yield x }
+    }
+}
+
+fn main() {
+    let mut iter = foo();
+    assert_eq!(iter.next(), Some(42));
+    assert_eq!(iter.next(), Some(3));
+    assert_eq!(iter.next(), Some(4));
+    assert_eq!(iter.next(), Some(5));
+    assert_eq!(iter.next(), None);
+    // `gen` blocks are fused
+    assert_eq!(iter.next(), None);
+
+    let mut iter = moved();
+    assert_eq!(iter.next(), Some(42));
+    assert_eq!(iter.next(), None);
+
+}
diff --git a/compiler/rustc_codegen_cranelift/rustfmt.toml b/compiler/rustc_codegen_cranelift/rustfmt.toml
index ebeca8662a5..0f884187add 100644
--- a/compiler/rustc_codegen_cranelift/rustfmt.toml
+++ b/compiler/rustc_codegen_cranelift/rustfmt.toml
@@ -1,4 +1,7 @@
-ignore = ["y.rs"]
+ignore = [
+    "y.rs",
+    "example/gen_block_iterate.rs", # uses edition 2024
+]
 
 # Matches rustfmt.toml of rustc
 version = "Two"
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index aa4d8ddad56..42540911785 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -617,6 +617,22 @@ fn replace_resume_ty_local<'tcx>(
     }
 }
 
+/// Transforms the `body` of the coroutine applying the following transform:
+///
+/// - Remove the `resume` argument.
+///
+/// Ideally the async lowering would not add the `resume` argument.
+///
+/// The async lowering step and the type / lifetime inference / checking are
+/// still using the `resume` argument for the time being. After this transform,
+/// the coroutine body doesn't have the `resume` argument.
+fn transform_gen_context<'tcx>(_tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+    // This leaves the local representing the `resume` argument in place,
+    // but turns it into a regular local variable. This is cheaper than
+    // adjusting all local references in the body after removing it.
+    body.arg_count = 1;
+}
+
 struct LivenessInfo {
     /// Which locals are live across any suspension point.
     saved_locals: CoroutineSavedLocals,
@@ -1337,7 +1353,15 @@ fn create_coroutine_resume_function<'tcx>(
     insert_switch(body, cases, &transform, TerminatorKind::Unreachable);
 
     make_coroutine_state_argument_indirect(tcx, body);
-    make_coroutine_state_argument_pinned(tcx, body);
+
+    match coroutine_kind {
+        // Iterator::next doesn't accept a pinned argument,
+        // unlike for all other coroutine kinds.
+        CoroutineKind::Gen(_) => {}
+        _ => {
+            make_coroutine_state_argument_pinned(tcx, body);
+        }
+    }
 
     // Make sure we remove dead blocks to remove
     // unrelated code from the drop part of the function
@@ -1504,6 +1528,7 @@ impl<'tcx> MirPass<'tcx> for StateTransform {
         };
 
         let is_async_kind = matches!(body.coroutine_kind(), Some(CoroutineKind::Async(_)));
+        let is_gen_kind = matches!(body.coroutine_kind(), Some(CoroutineKind::Gen(_)));
         let (state_adt_ref, state_args) = match body.coroutine_kind().unwrap() {
             CoroutineKind::Async(_) => {
                 // Compute Poll<return_ty>
@@ -1609,6 +1634,11 @@ impl<'tcx> MirPass<'tcx> for StateTransform {
         body.arg_count = 2; // self, resume arg
         body.spread_arg = None;
 
+        // Remove the context argument within generator bodies.
+        if is_gen_kind {
+            transform_gen_context(tcx, body);
+        }
+
         // The original arguments to the function are no longer arguments, mark them as such.
         // Otherwise they'll conflict with our new arguments, which although they don't have
         // argument_index set, will get emitted as unnamed arguments.
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 737acfbc600..8ea78b9b532 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -112,7 +112,13 @@ fn fn_sig_for_fn_abi<'tcx>(
             let pin_did = tcx.require_lang_item(LangItem::Pin, None);
             let pin_adt_ref = tcx.adt_def(pin_did);
             let pin_args = tcx.mk_args(&[env_ty.into()]);
-            let env_ty = Ty::new_adt(tcx, pin_adt_ref, pin_args);
+            let env_ty = if tcx.coroutine_is_gen(did) {
+                // Iterator::next doesn't accept a pinned argument,
+                // unlike for all other coroutine kinds.
+                env_ty
+            } else {
+                Ty::new_adt(tcx, pin_adt_ref, pin_args)
+            };
 
             let sig = sig.skip_binder();
             // The `FnSig` and the `ret_ty` here is for a coroutines main
@@ -121,6 +127,8 @@ fn fn_sig_for_fn_abi<'tcx>(
             // function in case this is a special coroutine backing an async construct.
             let (resume_ty, ret_ty) = if tcx.coroutine_is_async(did) {
                 // The signature should be `Future::poll(_, &mut Context<'_>) -> Poll<Output>`
+                assert_eq!(sig.yield_ty, tcx.types.unit);
+
                 let poll_did = tcx.require_lang_item(LangItem::Poll, None);
                 let poll_adt_ref = tcx.adt_def(poll_did);
                 let poll_args = tcx.mk_args(&[sig.return_ty.into()]);
@@ -140,7 +148,30 @@ fn fn_sig_for_fn_abi<'tcx>(
                 }
                 let context_mut_ref = Ty::new_task_context(tcx);
 
-                (context_mut_ref, ret_ty)
+                (Some(context_mut_ref), ret_ty)
+            } else if tcx.coroutine_is_gen(did) {
+                // The signature should be `Iterator::next(_) -> Option<Yield>`
+                let option_did = tcx.require_lang_item(LangItem::Option, None);
+                let option_adt_ref = tcx.adt_def(option_did);
+                let option_args = tcx.mk_args(&[sig.yield_ty.into()]);
+                let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
+
+                assert_eq!(sig.return_ty, tcx.types.unit);
+
+                // We have to replace the `ResumeTy` that is used for type and borrow checking
+                // with `()` which is used in codegen.
+                #[cfg(debug_assertions)]
+                {
+                    if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
+                        let expected_adt =
+                            tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
+                        assert_eq!(*resume_ty_adt, expected_adt);
+                    } else {
+                        panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
+                    };
+                }
+
+                (None, ret_ty)
             } else {
                 // The signature should be `Coroutine::resume(_, Resume) -> CoroutineState<Yield, Return>`
                 let state_did = tcx.require_lang_item(LangItem::CoroutineState, None);
@@ -148,19 +179,28 @@ fn fn_sig_for_fn_abi<'tcx>(
                 let state_args = tcx.mk_args(&[sig.yield_ty.into(), sig.return_ty.into()]);
                 let ret_ty = Ty::new_adt(tcx, state_adt_ref, state_args);
 
-                (sig.resume_ty, ret_ty)
+                (Some(sig.resume_ty), ret_ty)
             };
 
-            ty::Binder::bind_with_vars(
+            let fn_sig = if let Some(resume_ty) = resume_ty {
                 tcx.mk_fn_sig(
                     [env_ty, resume_ty],
                     ret_ty,
                     false,
                     hir::Unsafety::Normal,
                     rustc_target::spec::abi::Abi::Rust,
-                ),
-                bound_vars,
-            )
+                )
+            } else {
+                // `Iterator::next` doesn't have a `resume` argument.
+                tcx.mk_fn_sig(
+                    [env_ty],
+                    ret_ty,
+                    false,
+                    hir::Unsafety::Normal,
+                    rustc_target::spec::abi::Abi::Rust,
+                )
+            };
+            ty::Binder::bind_with_vars(fn_sig, bound_vars)
         }
         _ => bug!("unexpected type {:?} in Instance::fn_sig", ty),
     }
diff --git a/rustfmt.toml b/rustfmt.toml
index 88700779e87..e292a310742 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -39,4 +39,5 @@ ignore = [
     # these are ignored by a standard cargo fmt run
     "compiler/rustc_codegen_cranelift/y.rs", # running rustfmt breaks this file
     "compiler/rustc_codegen_cranelift/scripts",
+    "compiler/rustc_codegen_cranelift/example/gen_block_iterate.rs", # uses edition 2024
 ]

From b6e977243fa574963485219ad8047994ef2d791b Mon Sep 17 00:00:00 2001
From: "Celina G. Val" <celinval@amazon.com>
Date: Thu, 23 Nov 2023 12:29:20 -0800
Subject: [PATCH 49/71] Improve documentation and fix the fixme comment

---
 compiler/rustc_smir/src/rustc_smir/mod.rs |  3 +++
 compiler/stable_mir/src/crate_def.rs      | 15 +++++++++------
 compiler/stable_mir/src/mir/mono.rs       | 10 ++++++++--
 3 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
index dea881a2bb3..b8009b3ee49 100644
--- a/compiler/rustc_smir/src/rustc_smir/mod.rs
+++ b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -256,6 +256,9 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
         tables.tcx.symbol_name(instance).name.to_string()
     }
 
+    /// Retrieve the instance name for diagnostic messages.
+    ///
+    /// This will return the specialized name, e.g., `Vec<char>::new`.
     fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol {
         let tables = self.0.borrow_mut();
         let instance = tables.instances[def];
diff --git a/compiler/stable_mir/src/crate_def.rs b/compiler/stable_mir/src/crate_def.rs
index accd078b1ce..70ca9e6825e 100644
--- a/compiler/stable_mir/src/crate_def.rs
+++ b/compiler/stable_mir/src/crate_def.rs
@@ -1,4 +1,5 @@
-//! Module that define a common trait for things that represent a crate definition.
+//! Module that define a common trait for things that represent a crate definition,
+//! such as, a function, a trait, an enum, and any other definitions.
 
 use crate::ty::Span;
 use crate::{with, Crate, Symbol};
@@ -7,21 +8,23 @@ use crate::{with, Crate, Symbol};
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct DefId(pub(crate) usize);
 
-/// A trait for retrieving information about a crate definition.
+/// A trait for retrieving information about a particular definition.
 ///
 /// Implementors must provide the implementation of `def_id` which will be used to retrieve
-/// information about its definition.
+/// information about a crate's definition.
 pub trait CrateDef {
-    /// Retrieve the unique identifier for the given definition.
+    /// Retrieve the unique identifier for the current definition.
     fn def_id(&self) -> DefId;
 
-    /// Return the fully qualified name of the given definition.
+    /// Return the fully qualified name of the current definition.
     fn name(&self) -> Symbol {
         let def_id = self.def_id();
         with(|cx| cx.def_name(def_id, false))
     }
 
-    /// Return a trimmed name of the given definition.
+    /// Return a trimmed name of this definition.
+    ///
+    /// This can be used to print more user friendly diagnostic messages.
     ///
     /// If a symbol name can only be imported from one place for a type, and as
     /// long as it was not glob-imported anywhere in the current crate, we trim its
diff --git a/compiler/stable_mir/src/mir/mono.rs b/compiler/stable_mir/src/mir/mono.rs
index ddf601f6d76..8e884f17573 100644
--- a/compiler/stable_mir/src/mir/mono.rs
+++ b/compiler/stable_mir/src/mir/mono.rs
@@ -48,10 +48,16 @@ impl Instance {
         with(|context| context.instance_ty(self.def))
     }
 
+    /// Retrieve the instance's mangled name used for calling the given instance.
+    ///
+    /// This will also look up the correct name of instances from upstream crates.
     pub fn mangled_name(&self) -> Symbol {
         with(|context| context.instance_mangled_name(self.def))
     }
 
+    /// Retrieve the instance name for diagnostic messages.
+    ///
+    /// This will return the specialized name, e.g., `std::vec::Vec<u8>::new`.
     pub fn name(&self) -> Symbol {
         with(|context| context.instance_name(self.def, false))
     }
@@ -118,8 +124,8 @@ impl TryFrom<CrateItem> for Instance {
 
     fn try_from(item: CrateItem) -> Result<Self, Self::Error> {
         with(|context| {
-            /// FIXME(celinval):
-            /// - Check `has_body`.
+            // FIXME(celinval):
+            // - Return `Err` if instance does not have a body.
             if !context.requires_monomorphization(item.0) {
                 Ok(context.mono_instance(item))
             } else {

From 988fccb45dfab26d97ecb57bfdfda5be4656bc6b Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 23 Nov 2023 20:35:21 +0000
Subject: [PATCH 50/71] Exhaustively match CoroutineKind in fn_sig_for_fn_abi

---
 compiler/rustc_ty_utils/src/abi.rs | 120 ++++++++++++++++-------------
 1 file changed, 65 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 8ea78b9b532..ae368464256 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -98,6 +98,7 @@ fn fn_sig_for_fn_abi<'tcx>(
             )
         }
         ty::Coroutine(did, args, _) => {
+            let coroutine_kind = tcx.coroutine_kind(did).unwrap();
             let sig = args.as_coroutine().poly_sig();
 
             let bound_vars = tcx.mk_bound_variable_kinds_from_iter(
@@ -112,74 +113,83 @@ fn fn_sig_for_fn_abi<'tcx>(
             let pin_did = tcx.require_lang_item(LangItem::Pin, None);
             let pin_adt_ref = tcx.adt_def(pin_did);
             let pin_args = tcx.mk_args(&[env_ty.into()]);
-            let env_ty = if tcx.coroutine_is_gen(did) {
-                // Iterator::next doesn't accept a pinned argument,
-                // unlike for all other coroutine kinds.
-                env_ty
-            } else {
-                Ty::new_adt(tcx, pin_adt_ref, pin_args)
+            let env_ty = match coroutine_kind {
+                hir::CoroutineKind::Gen(_) => {
+                    // Iterator::next doesn't accept a pinned argument,
+                    // unlike for all other coroutine kinds.
+                    env_ty
+                }
+                hir::CoroutineKind::Async(_) | hir::CoroutineKind::Coroutine => {
+                    Ty::new_adt(tcx, pin_adt_ref, pin_args)
+                }
             };
 
             let sig = sig.skip_binder();
             // The `FnSig` and the `ret_ty` here is for a coroutines main
             // `Coroutine::resume(...) -> CoroutineState` function in case we
-            // have an ordinary coroutine, or the `Future::poll(...) -> Poll`
-            // function in case this is a special coroutine backing an async construct.
-            let (resume_ty, ret_ty) = if tcx.coroutine_is_async(did) {
-                // The signature should be `Future::poll(_, &mut Context<'_>) -> Poll<Output>`
-                assert_eq!(sig.yield_ty, tcx.types.unit);
+            // have an ordinary coroutine, the `Future::poll(...) -> Poll`
+            // function in case this is a special coroutine backing an async construct
+            // or the `Iterator::next(...) -> Option` function in case this is a
+            // special coroutine backing a gen construct.
+            let (resume_ty, ret_ty) = match coroutine_kind {
+                hir::CoroutineKind::Async(_) => {
+                    // The signature should be `Future::poll(_, &mut Context<'_>) -> Poll<Output>`
+                    assert_eq!(sig.yield_ty, tcx.types.unit);
 
-                let poll_did = tcx.require_lang_item(LangItem::Poll, None);
-                let poll_adt_ref = tcx.adt_def(poll_did);
-                let poll_args = tcx.mk_args(&[sig.return_ty.into()]);
-                let ret_ty = Ty::new_adt(tcx, poll_adt_ref, poll_args);
+                    let poll_did = tcx.require_lang_item(LangItem::Poll, None);
+                    let poll_adt_ref = tcx.adt_def(poll_did);
+                    let poll_args = tcx.mk_args(&[sig.return_ty.into()]);
+                    let ret_ty = Ty::new_adt(tcx, poll_adt_ref, poll_args);
 
-                // We have to replace the `ResumeTy` that is used for type and borrow checking
-                // with `&mut Context<'_>` which is used in codegen.
-                #[cfg(debug_assertions)]
-                {
-                    if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
-                        let expected_adt =
-                            tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
-                        assert_eq!(*resume_ty_adt, expected_adt);
-                    } else {
-                        panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
-                    };
+                    // We have to replace the `ResumeTy` that is used for type and borrow checking
+                    // with `&mut Context<'_>` which is used in codegen.
+                    #[cfg(debug_assertions)]
+                    {
+                        if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
+                            let expected_adt =
+                                tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
+                            assert_eq!(*resume_ty_adt, expected_adt);
+                        } else {
+                            panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
+                        };
+                    }
+                    let context_mut_ref = Ty::new_task_context(tcx);
+
+                    (Some(context_mut_ref), ret_ty)
                 }
-                let context_mut_ref = Ty::new_task_context(tcx);
+                hir::CoroutineKind::Gen(_) => {
+                    // The signature should be `Iterator::next(_) -> Option<Yield>`
+                    let option_did = tcx.require_lang_item(LangItem::Option, None);
+                    let option_adt_ref = tcx.adt_def(option_did);
+                    let option_args = tcx.mk_args(&[sig.yield_ty.into()]);
+                    let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
 
-                (Some(context_mut_ref), ret_ty)
-            } else if tcx.coroutine_is_gen(did) {
-                // The signature should be `Iterator::next(_) -> Option<Yield>`
-                let option_did = tcx.require_lang_item(LangItem::Option, None);
-                let option_adt_ref = tcx.adt_def(option_did);
-                let option_args = tcx.mk_args(&[sig.yield_ty.into()]);
-                let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
+                    assert_eq!(sig.return_ty, tcx.types.unit);
 
-                assert_eq!(sig.return_ty, tcx.types.unit);
+                    // We have to replace the `ResumeTy` that is used for type and borrow checking
+                    // with `()` which is used in codegen.
+                    #[cfg(debug_assertions)]
+                    {
+                        if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
+                            let expected_adt =
+                                tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
+                            assert_eq!(*resume_ty_adt, expected_adt);
+                        } else {
+                            panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
+                        };
+                    }
 
-                // We have to replace the `ResumeTy` that is used for type and borrow checking
-                // with `()` which is used in codegen.
-                #[cfg(debug_assertions)]
-                {
-                    if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
-                        let expected_adt =
-                            tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
-                        assert_eq!(*resume_ty_adt, expected_adt);
-                    } else {
-                        panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
-                    };
+                    (None, ret_ty)
                 }
+                hir::CoroutineKind::Coroutine => {
+                    // The signature should be `Coroutine::resume(_, Resume) -> CoroutineState<Yield, Return>`
+                    let state_did = tcx.require_lang_item(LangItem::CoroutineState, None);
+                    let state_adt_ref = tcx.adt_def(state_did);
+                    let state_args = tcx.mk_args(&[sig.yield_ty.into(), sig.return_ty.into()]);
+                    let ret_ty = Ty::new_adt(tcx, state_adt_ref, state_args);
 
-                (None, ret_ty)
-            } else {
-                // The signature should be `Coroutine::resume(_, Resume) -> CoroutineState<Yield, Return>`
-                let state_did = tcx.require_lang_item(LangItem::CoroutineState, None);
-                let state_adt_ref = tcx.adt_def(state_did);
-                let state_args = tcx.mk_args(&[sig.yield_ty.into(), sig.return_ty.into()]);
-                let ret_ty = Ty::new_adt(tcx, state_adt_ref, state_args);
-
-                (Some(sig.resume_ty), ret_ty)
+                    (Some(sig.resume_ty), ret_ty)
+                }
             };
 
             let fn_sig = if let Some(resume_ty) = resume_ty {

From 543e559c5300e8bd3be6d491897eaac327f9dc71 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 23 Nov 2023 20:36:59 +0000
Subject: [PATCH 51/71] Fix assertion

---
 compiler/rustc_ty_utils/src/abi.rs | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index ae368464256..85e137d29ac 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -165,19 +165,7 @@ fn fn_sig_for_fn_abi<'tcx>(
                     let ret_ty = Ty::new_adt(tcx, option_adt_ref, option_args);
 
                     assert_eq!(sig.return_ty, tcx.types.unit);
-
-                    // We have to replace the `ResumeTy` that is used for type and borrow checking
-                    // with `()` which is used in codegen.
-                    #[cfg(debug_assertions)]
-                    {
-                        if let ty::Adt(resume_ty_adt, _) = sig.resume_ty.kind() {
-                            let expected_adt =
-                                tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, None));
-                            assert_eq!(*resume_ty_adt, expected_adt);
-                        } else {
-                            panic!("expected `ResumeTy`, found `{:?}`", sig.resume_ty);
-                        };
-                    }
+                    assert_eq!(sig.resume_ty, tcx.types.unit);
 
                     (None, ret_ty)
                 }

From fdde5c77a834c8275c23648ddaca9c18adee07d4 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 23 Nov 2023 14:54:19 -0700
Subject: [PATCH 52/71] rustdoc: move ICE tests to ui

---
 tests/{rustdoc/ice-apit-46976.rs => rustdoc-ui/apit-46976.rs}    | 1 +
 tests/{rustdoc => rustdoc-ui}/auxiliary/issue-36031.rs           | 0
 tests/{rustdoc => rustdoc-ui}/auxiliary/issue-40936.rs           | 0
 tests/{rustdoc => rustdoc-ui}/auxiliary/issue-48414.rs           | 0
 .../circular-intra-doc-link-48414.rs}                            | 1 +
 .../ice-34423.rs => rustdoc-ui/hidden-trait-method-34423.rs}     | 1 +
 .../ice-36031.rs => rustdoc-ui/inherent-assoc-consts-36031.rs}   | 1 +
 .../nested-extern-crate-46271.rs}                                | 1 +
 .../nested-macro-rules-47639.rs}                                 | 1 +
 .../ice-extern-crate-40936.rs => rustdoc-ui/super-glob-40936.rs} | 1 +
 tests/rustdoc/{ => inline_local}/enum-variant-reexport-46766.rs  | 0
 ...{tuple-struct-34928.rs => tuple-struct-where-clause-34928.rs} | 0
 12 files changed, 7 insertions(+)
 rename tests/{rustdoc/ice-apit-46976.rs => rustdoc-ui/apit-46976.rs} (84%)
 rename tests/{rustdoc => rustdoc-ui}/auxiliary/issue-36031.rs (100%)
 rename tests/{rustdoc => rustdoc-ui}/auxiliary/issue-40936.rs (100%)
 rename tests/{rustdoc => rustdoc-ui}/auxiliary/issue-48414.rs (100%)
 rename tests/{rustdoc/ice-circular-intra-doc-link-48414.rs => rustdoc-ui/circular-intra-doc-link-48414.rs} (95%)
 rename tests/{rustdoc/ice-34423.rs => rustdoc-ui/hidden-trait-method-34423.rs} (91%)
 rename tests/{rustdoc/ice-36031.rs => rustdoc-ui/inherent-assoc-consts-36031.rs} (93%)
 rename tests/{rustdoc/ice-nested-extern-crate-46271.rs => rustdoc-ui/nested-extern-crate-46271.rs} (90%)
 rename tests/{rustdoc/ice-nested-macro-rules-47639.rs => rustdoc-ui/nested-macro-rules-47639.rs} (90%)
 rename tests/{rustdoc/ice-extern-crate-40936.rs => rustdoc-ui/super-glob-40936.rs} (91%)
 rename tests/rustdoc/{ => inline_local}/enum-variant-reexport-46766.rs (100%)
 rename tests/rustdoc/{tuple-struct-34928.rs => tuple-struct-where-clause-34928.rs} (100%)

diff --git a/tests/rustdoc/ice-apit-46976.rs b/tests/rustdoc-ui/apit-46976.rs
similarity index 84%
rename from tests/rustdoc/ice-apit-46976.rs
rename to tests/rustdoc-ui/apit-46976.rs
index e51cee2f056..c17688e3b1d 100644
--- a/tests/rustdoc/ice-apit-46976.rs
+++ b/tests/rustdoc-ui/apit-46976.rs
@@ -1,3 +1,4 @@
+// check-pass
 // https://github.com/rust-lang/rust/issues/46976
 
 pub fn ice(f: impl Fn()) {}
diff --git a/tests/rustdoc/auxiliary/issue-36031.rs b/tests/rustdoc-ui/auxiliary/issue-36031.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-36031.rs
rename to tests/rustdoc-ui/auxiliary/issue-36031.rs
diff --git a/tests/rustdoc/auxiliary/issue-40936.rs b/tests/rustdoc-ui/auxiliary/issue-40936.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-40936.rs
rename to tests/rustdoc-ui/auxiliary/issue-40936.rs
diff --git a/tests/rustdoc/auxiliary/issue-48414.rs b/tests/rustdoc-ui/auxiliary/issue-48414.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-48414.rs
rename to tests/rustdoc-ui/auxiliary/issue-48414.rs
diff --git a/tests/rustdoc/ice-circular-intra-doc-link-48414.rs b/tests/rustdoc-ui/circular-intra-doc-link-48414.rs
similarity index 95%
rename from tests/rustdoc/ice-circular-intra-doc-link-48414.rs
rename to tests/rustdoc-ui/circular-intra-doc-link-48414.rs
index 68dda3a25bb..46367ccaef9 100644
--- a/tests/rustdoc/ice-circular-intra-doc-link-48414.rs
+++ b/tests/rustdoc-ui/circular-intra-doc-link-48414.rs
@@ -1,4 +1,5 @@
 // aux-build:issue-48414.rs
+// check-pass
 
 // https://github.com/rust-lang/rust/issues/48414
 
diff --git a/tests/rustdoc/ice-34423.rs b/tests/rustdoc-ui/hidden-trait-method-34423.rs
similarity index 91%
rename from tests/rustdoc/ice-34423.rs
rename to tests/rustdoc-ui/hidden-trait-method-34423.rs
index 42e57ac7258..f3107d2379c 100644
--- a/tests/rustdoc/ice-34423.rs
+++ b/tests/rustdoc-ui/hidden-trait-method-34423.rs
@@ -1,3 +1,4 @@
+// check-pass
 // https://github.com/rust-lang/rust/issues/34423
 
 pub struct Foo;
diff --git a/tests/rustdoc/ice-36031.rs b/tests/rustdoc-ui/inherent-assoc-consts-36031.rs
similarity index 93%
rename from tests/rustdoc/ice-36031.rs
rename to tests/rustdoc-ui/inherent-assoc-consts-36031.rs
index 9f091384dfe..755fc1cfdff 100644
--- a/tests/rustdoc/ice-36031.rs
+++ b/tests/rustdoc-ui/inherent-assoc-consts-36031.rs
@@ -1,4 +1,5 @@
 // aux-build:issue-36031.rs
+// check-pass
 // build-aux-docs
 // ignore-cross-compile
 
diff --git a/tests/rustdoc/ice-nested-extern-crate-46271.rs b/tests/rustdoc-ui/nested-extern-crate-46271.rs
similarity index 90%
rename from tests/rustdoc/ice-nested-extern-crate-46271.rs
rename to tests/rustdoc-ui/nested-extern-crate-46271.rs
index 820a63f3498..d2ac38f3e45 100644
--- a/tests/rustdoc/ice-nested-extern-crate-46271.rs
+++ b/tests/rustdoc-ui/nested-extern-crate-46271.rs
@@ -1,3 +1,4 @@
+// check-pass
 // hopefully this doesn't cause an ICE
 
 // https://github.com/rust-lang/rust/issues/46271
diff --git a/tests/rustdoc/ice-nested-macro-rules-47639.rs b/tests/rustdoc-ui/nested-macro-rules-47639.rs
similarity index 90%
rename from tests/rustdoc/ice-nested-macro-rules-47639.rs
rename to tests/rustdoc-ui/nested-macro-rules-47639.rs
index c38dc2810cf..210b1e79cd2 100644
--- a/tests/rustdoc/ice-nested-macro-rules-47639.rs
+++ b/tests/rustdoc-ui/nested-macro-rules-47639.rs
@@ -1,3 +1,4 @@
+// check-pass
 // This should not ICE
 
 // https://github.com/rust-lang/rust/issues/47639
diff --git a/tests/rustdoc/ice-extern-crate-40936.rs b/tests/rustdoc-ui/super-glob-40936.rs
similarity index 91%
rename from tests/rustdoc/ice-extern-crate-40936.rs
rename to tests/rustdoc-ui/super-glob-40936.rs
index fafa4597174..a06e977b10a 100644
--- a/tests/rustdoc/ice-extern-crate-40936.rs
+++ b/tests/rustdoc-ui/super-glob-40936.rs
@@ -1,4 +1,5 @@
 // aux-build:issue-40936.rs
+// check-pass
 // build-aux-docs
 
 // https://github.com/rust-lang/rust/issues/40936
diff --git a/tests/rustdoc/enum-variant-reexport-46766.rs b/tests/rustdoc/inline_local/enum-variant-reexport-46766.rs
similarity index 100%
rename from tests/rustdoc/enum-variant-reexport-46766.rs
rename to tests/rustdoc/inline_local/enum-variant-reexport-46766.rs
diff --git a/tests/rustdoc/tuple-struct-34928.rs b/tests/rustdoc/tuple-struct-where-clause-34928.rs
similarity index 100%
rename from tests/rustdoc/tuple-struct-34928.rs
rename to tests/rustdoc/tuple-struct-where-clause-34928.rs

From cbf6bfc452641040609342326808888fad351df3 Mon Sep 17 00:00:00 2001
From: Matt Harding <majaharding@gmail.com>
Date: Fri, 10 Nov 2023 08:14:02 +0000
Subject: [PATCH 53/71] Fix tidy on untracked files with special character

Previously, the tidy tool would fault if an untracked file had a space
or other special characters in its name. If there was an untracked file
"foo bar", it would include the quoting in it's path and split on the
first space, giving output like this:
`skip untracked path "foo during rustfmt invocations`
---
 src/bootstrap/src/core/build_steps/format.rs | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/format.rs b/src/bootstrap/src/core/build_steps/format.rs
index 0e260e69c85..ea399cda53a 100644
--- a/src/bootstrap/src/core/build_steps/format.rs
+++ b/src/bootstrap/src/core/build_steps/format.rs
@@ -142,14 +142,17 @@ pub fn format(build: &Builder<'_>, check: bool, paths: &[PathBuf]) {
         };
         if in_working_tree {
             let untracked_paths_output = output(
-                build.config.git().arg("status").arg("--porcelain").arg("--untracked-files=normal"),
+                build
+                    .config
+                    .git()
+                    .arg("status")
+                    .arg("--porcelain")
+                    .arg("-z")
+                    .arg("--untracked-files=normal"),
+            );
+            let untracked_paths = untracked_paths_output.split_terminator('\0').filter_map(
+                |entry| entry.strip_prefix("?? "), // returns None if the prefix doesn't match
             );
-            let untracked_paths = untracked_paths_output
-                .lines()
-                .filter(|entry| entry.starts_with("??"))
-                .map(|entry| {
-                    entry.split(' ').nth(1).expect("every git status entry should list a path")
-                });
             let mut untracked_count = 0;
             for untracked_path in untracked_paths {
                 println!("skip untracked path {untracked_path} during rustfmt invocations");

From 4f64ff171bdd00873d6cdf8301f5cdddf999832f Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 23 Nov 2023 14:56:03 -0700
Subject: [PATCH 54/71] rustdoc: move doctest tests to folder

---
 tests/rustdoc/doctest/auxiliary/empty.rs                         | 1 +
 tests/rustdoc/{ => doctest}/doctest-cfg-feature-30252.rs         | 0
 tests/rustdoc/{ => doctest}/doctest-crate-attributes-38129.rs    | 0
 tests/rustdoc/{ => doctest}/doctest-hide-empty-line-23106.rs     | 0
 tests/rustdoc/{ => doctest}/doctest-ignore-32556.rs              | 0
 tests/rustdoc/{ => doctest}/doctest-include-43153.rs             | 0
 tests/rustdoc/{ => doctest}/doctest-macro-38219.rs               | 0
 tests/rustdoc/{ => doctest}/doctest-manual-crate-name.rs         | 0
 .../rustdoc/{ => doctest}/doctest-markdown-inline-parse-23744.rs | 0
 .../{ => doctest}/doctest-markdown-trailing-docblock-48377.rs    | 0
 .../{ => doctest}/doctest-multi-line-string-literal-25944.rs     | 0
 11 files changed, 1 insertion(+)
 create mode 100644 tests/rustdoc/doctest/auxiliary/empty.rs
 rename tests/rustdoc/{ => doctest}/doctest-cfg-feature-30252.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-crate-attributes-38129.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-hide-empty-line-23106.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-ignore-32556.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-include-43153.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-macro-38219.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-manual-crate-name.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-markdown-inline-parse-23744.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-markdown-trailing-docblock-48377.rs (100%)
 rename tests/rustdoc/{ => doctest}/doctest-multi-line-string-literal-25944.rs (100%)

diff --git a/tests/rustdoc/doctest/auxiliary/empty.rs b/tests/rustdoc/doctest/auxiliary/empty.rs
new file mode 100644
index 00000000000..d11c69f812a
--- /dev/null
+++ b/tests/rustdoc/doctest/auxiliary/empty.rs
@@ -0,0 +1 @@
+// intentionally empty
diff --git a/tests/rustdoc/doctest-cfg-feature-30252.rs b/tests/rustdoc/doctest/doctest-cfg-feature-30252.rs
similarity index 100%
rename from tests/rustdoc/doctest-cfg-feature-30252.rs
rename to tests/rustdoc/doctest/doctest-cfg-feature-30252.rs
diff --git a/tests/rustdoc/doctest-crate-attributes-38129.rs b/tests/rustdoc/doctest/doctest-crate-attributes-38129.rs
similarity index 100%
rename from tests/rustdoc/doctest-crate-attributes-38129.rs
rename to tests/rustdoc/doctest/doctest-crate-attributes-38129.rs
diff --git a/tests/rustdoc/doctest-hide-empty-line-23106.rs b/tests/rustdoc/doctest/doctest-hide-empty-line-23106.rs
similarity index 100%
rename from tests/rustdoc/doctest-hide-empty-line-23106.rs
rename to tests/rustdoc/doctest/doctest-hide-empty-line-23106.rs
diff --git a/tests/rustdoc/doctest-ignore-32556.rs b/tests/rustdoc/doctest/doctest-ignore-32556.rs
similarity index 100%
rename from tests/rustdoc/doctest-ignore-32556.rs
rename to tests/rustdoc/doctest/doctest-ignore-32556.rs
diff --git a/tests/rustdoc/doctest-include-43153.rs b/tests/rustdoc/doctest/doctest-include-43153.rs
similarity index 100%
rename from tests/rustdoc/doctest-include-43153.rs
rename to tests/rustdoc/doctest/doctest-include-43153.rs
diff --git a/tests/rustdoc/doctest-macro-38219.rs b/tests/rustdoc/doctest/doctest-macro-38219.rs
similarity index 100%
rename from tests/rustdoc/doctest-macro-38219.rs
rename to tests/rustdoc/doctest/doctest-macro-38219.rs
diff --git a/tests/rustdoc/doctest-manual-crate-name.rs b/tests/rustdoc/doctest/doctest-manual-crate-name.rs
similarity index 100%
rename from tests/rustdoc/doctest-manual-crate-name.rs
rename to tests/rustdoc/doctest/doctest-manual-crate-name.rs
diff --git a/tests/rustdoc/doctest-markdown-inline-parse-23744.rs b/tests/rustdoc/doctest/doctest-markdown-inline-parse-23744.rs
similarity index 100%
rename from tests/rustdoc/doctest-markdown-inline-parse-23744.rs
rename to tests/rustdoc/doctest/doctest-markdown-inline-parse-23744.rs
diff --git a/tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs b/tests/rustdoc/doctest/doctest-markdown-trailing-docblock-48377.rs
similarity index 100%
rename from tests/rustdoc/doctest-markdown-trailing-docblock-48377.rs
rename to tests/rustdoc/doctest/doctest-markdown-trailing-docblock-48377.rs
diff --git a/tests/rustdoc/doctest-multi-line-string-literal-25944.rs b/tests/rustdoc/doctest/doctest-multi-line-string-literal-25944.rs
similarity index 100%
rename from tests/rustdoc/doctest-multi-line-string-literal-25944.rs
rename to tests/rustdoc/doctest/doctest-multi-line-string-literal-25944.rs

From ee9223ff973bc3006da81611fb1cd36850d2fab8 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 23 Nov 2023 20:10:44 -0500
Subject: [PATCH 55/71] Enforce NonZeroUsize on thread count

This allows avoiding some if != 0 checks when allocating worker-local
datasets.
---
 .../rustc_data_structures/src/sync/worker_local.rs    | 11 +++++++----
 compiler/rustc_interface/src/util.rs                  |  2 +-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_data_structures/src/sync/worker_local.rs b/compiler/rustc_data_structures/src/sync/worker_local.rs
index ffafdba13ce..b34d3dd9044 100644
--- a/compiler/rustc_data_structures/src/sync/worker_local.rs
+++ b/compiler/rustc_data_structures/src/sync/worker_local.rs
@@ -1,6 +1,7 @@
 use parking_lot::Mutex;
 use std::cell::Cell;
 use std::cell::OnceCell;
+use std::num::NonZeroUsize;
 use std::ops::Deref;
 use std::ptr;
 use std::sync::Arc;
@@ -30,7 +31,7 @@ impl RegistryId {
 }
 
 struct RegistryData {
-    thread_limit: usize,
+    thread_limit: NonZeroUsize,
     threads: Mutex<usize>,
 }
 
@@ -60,7 +61,7 @@ thread_local! {
 
 impl Registry {
     /// Creates a registry which can hold up to `thread_limit` threads.
-    pub fn new(thread_limit: usize) -> Self {
+    pub fn new(thread_limit: NonZeroUsize) -> Self {
         Registry(Arc::new(RegistryData { thread_limit, threads: Mutex::new(0) }))
     }
 
@@ -73,7 +74,7 @@ impl Registry {
     /// Panics if the thread limit is hit or if the thread already has an associated registry.
     pub fn register(&self) {
         let mut threads = self.0.threads.lock();
-        if *threads < self.0.thread_limit {
+        if *threads < self.0.thread_limit.get() {
             REGISTRY.with(|registry| {
                 if registry.get().is_some() {
                     drop(threads);
@@ -126,7 +127,9 @@ impl<T> WorkerLocal<T> {
         {
             let registry = Registry::current();
             WorkerLocal {
-                locals: (0..registry.0.thread_limit).map(|i| CacheAligned(initial(i))).collect(),
+                locals: (0..registry.0.thread_limit.get())
+                    .map(|i| CacheAligned(initial(i)))
+                    .collect(),
                 registry,
             }
         }
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 8df3648a065..b3ab01a740a 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -107,7 +107,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
     use rustc_query_impl::QueryCtxt;
     use rustc_query_system::query::{deadlock, QueryContext};
 
-    let registry = sync::Registry::new(threads);
+    let registry = sync::Registry::new(std::num::NonZeroUsize::new(threads).unwrap());
 
     if !sync::is_dyn_thread_safe() {
         return run_in_thread_with_globals(edition, || {

From 107ea5d3bcc154b4c1dd31e646bb8fc41d4e7531 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 23 Nov 2023 20:15:29 -0500
Subject: [PATCH 56/71] Move WorkerLocal out of QueryArenas

This cuts librustc_driver.so code size by ~85 kilobytes.
---
 compiler/rustc_middle/src/query/mod.rs      | 1 -
 compiler/rustc_middle/src/query/plumbing.rs | 7 ++++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index c982e2a9325..22f3d733dc3 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -61,7 +61,6 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::Lrc;
-use rustc_data_structures::sync::WorkerLocal;
 use rustc_data_structures::unord::UnordSet;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir as hir;
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index f4a8ada8f68..ac3538f181e 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -11,6 +11,7 @@ use field_offset::FieldOffset;
 use measureme::StringId;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::AtomicU64;
+use rustc_data_structures::sync::WorkerLocal;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::hir_id::OwnerId;
@@ -71,7 +72,7 @@ pub struct QuerySystemFns<'tcx> {
 
 pub struct QuerySystem<'tcx> {
     pub states: QueryStates<'tcx>,
-    pub arenas: QueryArenas<'tcx>,
+    pub arenas: WorkerLocal<QueryArenas<'tcx>>,
     pub caches: QueryCaches<'tcx>,
     pub dynamic_queries: DynamicQueries<'tcx>,
 
@@ -370,7 +371,7 @@ macro_rules! define_callbacks {
 
         pub struct QueryArenas<'tcx> {
             $($(#[$attr])* pub $name: query_if_arena!([$($modifiers)*]
-                (WorkerLocal<TypedArena<<$V as Deref>::Target>>)
+                (TypedArena<<$V as Deref>::Target>)
                 ()
             ),)*
         }
@@ -379,7 +380,7 @@ macro_rules! define_callbacks {
             fn default() -> Self {
                 Self {
                     $($name: query_if_arena!([$($modifiers)*]
-                        (WorkerLocal::new(|_| Default::default()))
+                        (Default::default())
                         ()
                     ),)*
                 }

From a994f46421f5ac551905e336c1c1b78a8885f6a5 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 23 Nov 2023 17:16:19 -0800
Subject: [PATCH 57/71] Add test of rustdoc sort order for stable vs unstable
 item

---
 tests/rustdoc/stability.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/rustdoc/stability.rs b/tests/rustdoc/stability.rs
index 90be2050d92..5d8286d8116 100644
--- a/tests/rustdoc/stability.rs
+++ b/tests/rustdoc/stability.rs
@@ -2,6 +2,14 @@
 
 #![unstable(feature = "test", issue = "none")]
 
+// @has stability/index.html
+// @has - '//ul[@class="item-table"]/li[1]//a' Unstable
+// @has - '//ul[@class="item-table"]/li[2]//a' AaStable
+// @has - '//ul[@class="item-table"]/li[3]//a' ZzStable
+
+#[stable(feature = "rust2", since = "2.2.2")]
+pub struct AaStable;
+
 pub struct Unstable {
     // @has stability/struct.Unstable.html \
     //      '//span[@class="item-info"]//div[@class="stab unstable"]' \
@@ -10,3 +18,6 @@ pub struct Unstable {
     pub foo: u32,
     pub bar: u32,
 }
+
+#[stable(feature = "rust2", since = "2.2.2")]
+pub struct ZzStable;

From b77aa74a2d6b0b5cac167a942a7c53931dc715c9 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 23 Nov 2023 16:38:31 -0800
Subject: [PATCH 58/71] Sort unstable items last in rustdoc, instead of first

---
 src/librustdoc/html/render/print_item.rs | 4 ++--
 tests/rustdoc/stability.rs               | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 927bec4251e..ce9e1bcf488 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -369,8 +369,8 @@ fn item_module(w: &mut Buffer, cx: &mut Context<'_>, item: &clean::Item, items:
         if let (Some(a), Some(b)) = (s1, s2) {
             match (a.is_stable(), b.is_stable()) {
                 (true, true) | (false, false) => {}
-                (false, true) => return Ordering::Less,
-                (true, false) => return Ordering::Greater,
+                (false, true) => return Ordering::Greater,
+                (true, false) => return Ordering::Less,
             }
         }
         let lhs = i1.name.unwrap_or(kw::Empty);
diff --git a/tests/rustdoc/stability.rs b/tests/rustdoc/stability.rs
index 5d8286d8116..c4d7118d07f 100644
--- a/tests/rustdoc/stability.rs
+++ b/tests/rustdoc/stability.rs
@@ -3,9 +3,9 @@
 #![unstable(feature = "test", issue = "none")]
 
 // @has stability/index.html
-// @has - '//ul[@class="item-table"]/li[1]//a' Unstable
-// @has - '//ul[@class="item-table"]/li[2]//a' AaStable
-// @has - '//ul[@class="item-table"]/li[3]//a' ZzStable
+// @has - '//ul[@class="item-table"]/li[1]//a' AaStable
+// @has - '//ul[@class="item-table"]/li[2]//a' ZzStable
+// @has - '//ul[@class="item-table"]/li[3]//a' Unstable
 
 #[stable(feature = "rust2", since = "2.2.2")]
 pub struct AaStable;

From b81e788d16d9656b9fd8905de9a3f382ccdbb56c Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 23 Nov 2023 21:47:08 -0500
Subject: [PATCH 59/71] Indicate that multiplication in Layout::array cannot
 overflow

This allows LLVM to optimize comparisons to zero before & after the
multiplication into one, saving on code size and eliminating an (always
true) branch from most Vec allocations.
---
 library/core/src/alloc/layout.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
index 65946e09ff9..9ef0a7d7608 100644
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -450,7 +450,11 @@ impl Layout {
                 return Err(LayoutError);
             }
 
-            let array_size = element_size * n;
+            // SAFETY: We just checked that we won't overflow `usize` when we multiply.
+            // This is a useless hint inside this function, but after inlining this helps
+            // deduplicate checks for whether the overall capacity is zero (e.g., in RawVec's
+            // allocation path) before/after this multiplication.
+            let array_size = unsafe { element_size.unchecked_mul(n) };
 
             // SAFETY: We just checked above that the `array_size` will not
             // exceed `isize::MAX` even when rounded up to the alignment.

From 879aff9cf0419b3e0c1b656f8d9b780d641ea9a9 Mon Sep 17 00:00:00 2001
From: Petr Sumbera <sumbera@volny.cz>
Date: Fri, 24 Nov 2023 09:45:23 +0100
Subject: [PATCH 60/71] Fix build on Solaris after #117815.

---
 src/bootstrap/src/bin/main.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/bin/main.rs b/src/bootstrap/src/bin/main.rs
index 35010bea818..7e6fdb7092d 100644
--- a/src/bootstrap/src/bin/main.rs
+++ b/src/bootstrap/src/bin/main.rs
@@ -14,9 +14,9 @@ use std::{
     io::{self, IsTerminal},
 };
 
-#[cfg(all(any(unix, windows), not(target_os = "solaris")))]
-use bootstrap::t;
-use bootstrap::{find_recent_config_change_ids, Build, Config, Subcommand, CONFIG_CHANGE_HISTORY};
+use bootstrap::{
+    find_recent_config_change_ids, t, Build, Config, Subcommand, CONFIG_CHANGE_HISTORY,
+};
 
 fn main() {
     let args = env::args().skip(1).collect::<Vec<_>>();

From a5dff378f54821b763ffd06ff3d2702777c055d6 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 24 Nov 2023 11:15:53 +0100
Subject: [PATCH 61/71] memcpy assumptions: update GCC link

---
 library/core/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 921a0fb6a9f..d44cf299c27 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -27,7 +27,7 @@
 //!   the `n` parameter is 0, the function is assumed to not be UB. Furthermore, for `memcpy`, if
 //!   source and target pointer are equal, the function is assumed to not be UB.
 //!   (Note that these are standard assumptions among compilers:
-//!   [clang](https://reviews.llvm.org/D86993) and [GCC](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=32667) do the same.)
+//!   [clang](https://reviews.llvm.org/D86993) and [GCC](https://gcc.gnu.org/onlinedocs/gcc/Standards.html#C-Language) do the same.)
 //!   These functions are often provided by the system libc, but can also be provided by the
 //!   [compiler-builtins crate](https://crates.io/crates/compiler_builtins).
 //!   Note that the library does not guarantee that it will always make these assumptions, so Rust

From 42a9b0d7abe12968f7c0c6f0f3ca4deb0b12973e Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Fri, 24 Nov 2023 15:20:02 +0100
Subject: [PATCH 62/71] EvalCtxt::commit_if_ok don't inherit nested goals

---
 .../src/solve/eval_ctxt/commit_if_ok.rs                    | 6 +++---
 compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs  | 7 ++++++-
 compiler/rustc_trait_selection/src/solve/mod.rs            | 5 -----
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/commit_if_ok.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/commit_if_ok.rs
index c47152c601c..67b6801059a 100644
--- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/commit_if_ok.rs
+++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/commit_if_ok.rs
@@ -1,4 +1,4 @@
-use super::EvalCtxt;
+use super::{EvalCtxt, NestedGoals};
 use crate::solve::inspect;
 use rustc_middle::traits::query::NoSolution;
 
@@ -14,7 +14,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
             predefined_opaques_in_body: self.predefined_opaques_in_body,
             max_input_universe: self.max_input_universe,
             search_graph: self.search_graph,
-            nested_goals: self.nested_goals.clone(),
+            nested_goals: NestedGoals::new(),
             tainted: self.tainted,
             inspect: self.inspect.new_probe(),
         };
@@ -32,7 +32,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
                 tainted,
                 inspect,
             } = nested_ecx;
-            self.nested_goals = nested_goals;
+            self.nested_goals.extend(nested_goals);
             self.tainted = tainted;
             self.inspect.integrate_snapshot(inspect);
         } else {
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
index 23ce0a301ce..e9d7e6675b4 100644
--- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
@@ -108,7 +108,7 @@ pub(super) struct NestedGoals<'tcx> {
     pub(super) goals: Vec<Goal<'tcx, ty::Predicate<'tcx>>>,
 }
 
-impl NestedGoals<'_> {
+impl<'tcx> NestedGoals<'tcx> {
     pub(super) fn new() -> Self {
         Self { normalizes_to_hack_goal: None, goals: Vec::new() }
     }
@@ -116,6 +116,11 @@ impl NestedGoals<'_> {
     pub(super) fn is_empty(&self) -> bool {
         self.normalizes_to_hack_goal.is_none() && self.goals.is_empty()
     }
+
+    pub(super) fn extend(&mut self, other: NestedGoals<'tcx>) {
+        assert_eq!(other.normalizes_to_hack_goal, None);
+        self.goals.extend(other.goals)
+    }
 }
 
 #[derive(PartialEq, Eq, Debug, Hash, HashStable, Clone, Copy)]
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
index 65d061ab3f4..0cf4799f86d 100644
--- a/compiler/rustc_trait_selection/src/solve/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -334,11 +334,6 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
             }
         }
 
-        // FIXME(@lcnr): If the normalization of the alias adds an inference constraint which
-        // causes a previously added goal to fail, then we treat the alias as rigid.
-        //
-        // These feels like a potential issue, I should look into writing some tests here
-        // and then probably changing `commit_if_ok` to not inherit the parent goals.
         match self.commit_if_ok(|this| {
             let normalized_ty = this.next_ty_infer();
             let normalizes_to_goal = Goal::new(

From 16040a16285e3bfde82c3e4216d16a6e566494da Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Fri, 24 Nov 2023 14:32:05 +0000
Subject: [PATCH 63/71] Add `Span` to `TraitBoundModifier`

---
 compiler/rustc_ast/src/ast.rs                 |  7 +--
 compiler/rustc_ast_lowering/src/lib.rs        |  4 +-
 .../rustc_ast_passes/src/ast_validation.rs    |  5 +-
 compiler/rustc_ast_pretty/src/pprust/state.rs |  2 +-
 compiler/rustc_expand/src/build.rs            |  4 +-
 compiler/rustc_parse/src/parser/ty.rs         |  2 +-
 src/tools/rustfmt/src/types.rs                |  2 +-
 .../assoc-type-const-bound-usage.stderr       |  2 +-
 .../assoc-type.stderr                         |  2 +-
 ...st-bound-on-not-const-associated-fn.stderr |  4 +-
 .../const-drop.precise.stderr                 |  2 +-
 .../const-drop.stock.stderr                   |  2 +-
 .../super-traits-fail-2.nn.stderr             |  2 +-
 .../super-traits-fail-2.yn.stderr             |  2 +-
 .../super-traits-fail-3.nn.stderr             |  2 +-
 .../super-traits-fail-3.yn.stderr             |  2 +-
 .../tilde-const-and-const-params.stderr       |  4 +-
 .../tilde-const-invalid-places.stderr         | 42 +++++++-------
 .../trait-where-clause.stderr                 |  4 +-
 tests/ui/stats/hir-stats.stderr               | 58 +++++++++----------
 20 files changed, 76 insertions(+), 78 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 83fe95f16f9..10776f31c07 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -301,7 +301,7 @@ pub enum TraitBoundModifier {
     Maybe,
 
     /// `~const Trait`
-    MaybeConst,
+    MaybeConst(Span),
 
     /// `~const !Trait`
     //
@@ -317,8 +317,7 @@ pub enum TraitBoundModifier {
 impl TraitBoundModifier {
     pub fn to_constness(self) -> Const {
         match self {
-            // FIXME(effects) span
-            Self::MaybeConst => Const::Yes(DUMMY_SP),
+            Self::MaybeConst(span) => Const::Yes(span),
             _ => Const::No,
         }
     }
@@ -3155,7 +3154,7 @@ mod size_asserts {
     static_assert_size!(ForeignItem, 96);
     static_assert_size!(ForeignItemKind, 24);
     static_assert_size!(GenericArg, 24);
-    static_assert_size!(GenericBound, 56);
+    static_assert_size!(GenericBound, 64);
     static_assert_size!(Generics, 40);
     static_assert_size!(Impl, 136);
     static_assert_size!(Item, 136);
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index e9554f10776..96af090bccd 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1369,7 +1369,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             GenericBound::Trait(
                                 ty,
                                 modifier @ (TraitBoundModifier::None
-                                | TraitBoundModifier::MaybeConst
+                                | TraitBoundModifier::MaybeConst(_)
                                 | TraitBoundModifier::Negative),
                             ) => {
                                 Some(this.lower_poly_trait_ref(ty, itctx, modifier.to_constness()))
@@ -2227,7 +2227,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_trait_bound_modifier(&mut self, f: TraitBoundModifier) -> hir::TraitBoundModifier {
         match f {
             TraitBoundModifier::None => hir::TraitBoundModifier::None,
-            TraitBoundModifier::MaybeConst => hir::TraitBoundModifier::MaybeConst,
+            TraitBoundModifier::MaybeConst(_) => hir::TraitBoundModifier::MaybeConst,
 
             TraitBoundModifier::Negative => {
                 if self.tcx.features().negative_bounds {
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 1a45c8eb1a5..45b5e63bd1b 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1203,7 +1203,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 (BoundKind::TraitObject, TraitBoundModifier::Maybe) => {
                     self.err_handler().emit_err(errors::OptionalTraitObject { span: poly.span });
                 }
-                (_, TraitBoundModifier::MaybeConst)
+                (_, &TraitBoundModifier::MaybeConst(span))
                     if let Some(reason) = &self.disallow_tilde_const =>
                 {
                     let reason = match reason {
@@ -1224,8 +1224,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                         }
                         DisallowTildeConstContext::Item => errors::TildeConstReason::Item,
                     };
-                    self.err_handler()
-                        .emit_err(errors::TildeConstDisallowed { span: bound.span(), reason });
+                    self.err_handler().emit_err(errors::TildeConstDisallowed { span, reason });
                 }
                 (_, TraitBoundModifier::MaybeConstMaybe) => {
                     self.err_handler().emit_err(errors::OptionalConstExclusive {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index da91c3c8a19..a3bf47328ea 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1515,7 +1515,7 @@ impl<'a> State<'a> {
                         TraitBoundModifier::Maybe => {
                             self.word("?");
                         }
-                        TraitBoundModifier::MaybeConst => {
+                        TraitBoundModifier::MaybeConst(_) => {
                             self.word_space("~const");
                         }
                         TraitBoundModifier::MaybeConstNegative => {
diff --git a/compiler/rustc_expand/src/build.rs b/compiler/rustc_expand/src/build.rs
index 7de46994434..9a8d0d691f0 100644
--- a/compiler/rustc_expand/src/build.rs
+++ b/compiler/rustc_expand/src/build.rs
@@ -4,7 +4,7 @@ use rustc_ast::{self as ast, AttrVec, BlockCheckMode, Expr, LocalKind, PatKind,
 use rustc_ast::{attr, token, util::literal};
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::Span;
+use rustc_span::{Span, DUMMY_SP};
 use thin_vec::{thin_vec, ThinVec};
 
 impl<'a> ExtCtxt<'a> {
@@ -135,7 +135,7 @@ impl<'a> ExtCtxt<'a> {
         ast::GenericBound::Trait(
             self.poly_trait_ref(path.span, path),
             if is_const {
-                ast::TraitBoundModifier::MaybeConst
+                ast::TraitBoundModifier::MaybeConst(DUMMY_SP)
             } else {
                 ast::TraitBoundModifier::None
             },
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 75617b1b3ea..b1a57c3dfd9 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -37,7 +37,7 @@ impl BoundModifiers {
             (BoundPolarity::Positive, None) => TraitBoundModifier::None,
             (BoundPolarity::Negative(_), None) => TraitBoundModifier::Negative,
             (BoundPolarity::Maybe(_), None) => TraitBoundModifier::Maybe,
-            (BoundPolarity::Positive, Some(_)) => TraitBoundModifier::MaybeConst,
+            (BoundPolarity::Positive, Some(sp)) => TraitBoundModifier::MaybeConst(sp),
             (BoundPolarity::Negative(_), Some(_)) => TraitBoundModifier::MaybeConstNegative,
             (BoundPolarity::Maybe(_), Some(_)) => TraitBoundModifier::MaybeConstMaybe,
         }
diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs
index 127aff913e3..8ca27150371 100644
--- a/src/tools/rustfmt/src/types.rs
+++ b/src/tools/rustfmt/src/types.rs
@@ -546,7 +546,7 @@ impl Rewrite for ast::GenericBound {
                     ast::TraitBoundModifier::Maybe => poly_trait_ref
                         .rewrite(context, shape.offset_left(1)?)
                         .map(|s| format!("?{}", s)),
-                    ast::TraitBoundModifier::MaybeConst => poly_trait_ref
+                    ast::TraitBoundModifier::MaybeConst(_) => poly_trait_ref
                         .rewrite(context, shape.offset_left(7)?)
                         .map(|s| format!("~const {}", s)),
                     ast::TraitBoundModifier::MaybeConstMaybe => poly_trait_ref
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type-const-bound-usage.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type-const-bound-usage.stderr
index e6b663c47d7..1b88839984f 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type-const-bound-usage.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type-const-bound-usage.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/assoc-type-const-bound-usage.rs:7:17
    |
 LL |     type Assoc: ~const Foo;
-   |                 ^^^^^^^^^^
+   |                 ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type.stderr
index 7df16ca5a3b..290ef6e2f5f 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/assoc-type.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/assoc-type.rs:17:15
    |
 LL |     type Bar: ~const std::ops::Add;
-   |               ^^^^^^^^^^^^^^^^^^^^
+   |               ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-bound-on-not-const-associated-fn.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-bound-on-not-const-associated-fn.stderr
index 9210f642706..db48c170d1c 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-bound-on-not-const-associated-fn.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-bound-on-not-const-associated-fn.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/const-bound-on-not-const-associated-fn.rs:9:40
    |
 LL |     fn do_something_else() where Self: ~const MyTrait;
-   |                                        ^^^^^^^^^^^^^^
+   |                                        ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/const-bound-on-not-const-associated-fn.rs:9:8
@@ -14,7 +14,7 @@ error: `~const` is not allowed here
   --> $DIR/const-bound-on-not-const-associated-fn.rs:20:32
    |
 LL |     pub fn foo(&self) where T: ~const MyTrait {
-   |                                ^^^^^^^^^^^^^^
+   |                                ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/const-bound-on-not-const-associated-fn.rs:20:12
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr
index be75e852e0a..217b02f68ad 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/const-drop.rs:67:38
    |
 LL |     pub struct ConstDropWithBound<T: ~const SomeTrait>(pub core::marker::PhantomData<T>);
-   |                                      ^^^^^^^^^^^^^^^^
+   |                                      ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr
index be75e852e0a..217b02f68ad 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/const-drop.rs:67:38
    |
 LL |     pub struct ConstDropWithBound<T: ~const SomeTrait>(pub core::marker::PhantomData<T>);
-   |                                      ^^^^^^^^^^^^^^^^
+   |                                      ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.nn.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.nn.stderr
index 204f0f9f89f..12bcdb034bc 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.nn.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.nn.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: ~const Foo {}
-   |            ^^^^^^^^^^
+   |            ^^^^^^
    |
 note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
   --> $DIR/super-traits-fail-2.rs:11:1
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
index 06330958b8e..d705244c0ee 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: ~const Foo {}
-   |            ^^^^^^^^^^
+   |            ^^^^^^
    |
 note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
   --> $DIR/super-traits-fail-2.rs:11:1
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.nn.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.nn.stderr
index 77b13a351e2..e10c51ef45a 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.nn.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.nn.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/super-traits-fail-3.rs:13:12
    |
 LL | trait Bar: ~const Foo {}
-   |            ^^^^^^^^^^
+   |            ^^^^^^
    |
 note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
   --> $DIR/super-traits-fail-3.rs:13:1
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yn.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yn.stderr
index 2e41eb9b4c4..34f6515b572 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yn.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yn.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/super-traits-fail-3.rs:13:12
    |
 LL | trait Bar: ~const Foo {}
-   |            ^^^^^^^^^^
+   |            ^^^^^^
    |
 note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
   --> $DIR/super-traits-fail-3.rs:13:1
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-and-const-params.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-and-const-params.stderr
index be7a83dc184..b479793814c 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-and-const-params.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-and-const-params.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-and-const-params.rs:9:15
    |
 LL |     fn add<A: ~const Add42>(self) -> Foo<{ A::add(N) }> {
-   |               ^^^^^^^^^^^^
+   |               ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-and-const-params.rs:9:8
@@ -14,7 +14,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-and-const-params.rs:27:11
    |
 LL | fn bar<A: ~const Add42, const N: usize>(_: Foo<N>) -> Foo<{ A::add(N) }> {
-   |           ^^^^^^^^^^^^
+   |           ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-and-const-params.rs:27:4
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-invalid-places.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-invalid-places.stderr
index c14f9a99035..c6e18924fd8 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-invalid-places.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-invalid-places.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:7:26
    |
 LL | fn non_const_function<T: ~const Trait>() {}
-   |                          ^^^^^^^^^^^^
+   |                          ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:7:4
@@ -14,7 +14,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:9:18
    |
 LL | struct Struct<T: ~const Trait> { field: T }
-   |                  ^^^^^^^^^^^^
+   |                  ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -22,7 +22,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:10:23
    |
 LL | struct TupleStruct<T: ~const Trait>(T);
-   |                       ^^^^^^^^^^^^
+   |                       ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -30,7 +30,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:11:22
    |
 LL | struct UnitStruct<T: ~const Trait>;
-   |                      ^^^^^^^^^^^^
+   |                      ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -38,7 +38,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:13:14
    |
 LL | enum Enum<T: ~const Trait> { Variant(T) }
-   |              ^^^^^^^^^^^^
+   |              ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -46,7 +46,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:15:16
    |
 LL | union Union<T: ~const Trait> { field: T }
-   |                ^^^^^^^^^^^^
+   |                ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -54,7 +54,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:17:14
    |
 LL | type Type<T: ~const Trait> = T;
-   |              ^^^^^^^^^^^^
+   |              ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -62,7 +62,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:19:19
    |
 LL | const CONSTANT<T: ~const Trait>: () = ();
-   |                   ^^^^^^^^^^^^
+   |                   ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -70,7 +70,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:23:18
    |
 LL |     type Type<T: ~const Trait>: ~const Trait;
-   |                  ^^^^^^^^^^^^
+   |                  ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -78,7 +78,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:23:33
    |
 LL |     type Type<T: ~const Trait>: ~const Trait;
-   |                                 ^^^^^^^^^^^^
+   |                                 ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -86,7 +86,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:26:30
    |
 LL |     fn non_const_function<T: ~const Trait>();
-   |                              ^^^^^^^^^^^^
+   |                              ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:26:8
@@ -98,7 +98,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:27:23
    |
 LL |     const CONSTANT<T: ~const Trait>: ();
-   |                       ^^^^^^^^^^^^
+   |                       ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -106,7 +106,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:32:18
    |
 LL |     type Type<T: ~const Trait> = ();
-   |                  ^^^^^^^^^^^^
+   |                  ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -114,7 +114,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:33:30
    |
 LL |     fn non_const_function<T: ~const Trait>() {}
-   |                              ^^^^^^^^^^^^
+   |                              ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:33:8
@@ -126,7 +126,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:34:23
    |
 LL |     const CONSTANT<T: ~const Trait>: () = ();
-   |                       ^^^^^^^^^^^^
+   |                       ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -134,7 +134,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:41:18
    |
 LL |     type Type<T: ~const Trait> = ();
-   |                  ^^^^^^^^^^^^
+   |                  ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -142,7 +142,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:43:30
    |
 LL |     fn non_const_function<T: ~const Trait>() {}
-   |                              ^^^^^^^^^^^^
+   |                              ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:43:8
@@ -154,7 +154,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:44:23
    |
 LL |     const CONSTANT<T: ~const Trait>: () = ();
-   |                       ^^^^^^^^^^^^
+   |                       ^^^^^^
    |
    = note: this item cannot have `~const` trait bounds
 
@@ -162,7 +162,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:49:15
    |
 LL | trait Child0: ~const Trait {}
-   |               ^^^^^^^^^^^^
+   |               ^^^^^^
    |
 note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:49:1
@@ -174,7 +174,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:50:26
    |
 LL | trait Child1 where Self: ~const Trait {}
-   |                          ^^^^^^^^^^^^
+   |                          ^^^^^^
    |
 note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:50:1
@@ -186,7 +186,7 @@ error: `~const` is not allowed here
   --> $DIR/tilde-const-invalid-places.rs:53:9
    |
 LL | impl<T: ~const Trait> Trait for T {}
-   |         ^^^^^^^^^^^^
+   |         ^^^^^^
    |
 note: this impl is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/tilde-const-invalid-places.rs:53:1
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-where-clause.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-where-clause.stderr
index 3d6fedbabbf..abe24b662a2 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-where-clause.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-where-clause.stderr
@@ -2,7 +2,7 @@ error: `~const` is not allowed here
   --> $DIR/trait-where-clause.rs:8:24
    |
 LL |     fn b() where Self: ~const Bar;
-   |                        ^^^^^^^^^^
+   |                        ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/trait-where-clause.rs:8:8
@@ -14,7 +14,7 @@ error: `~const` is not allowed here
   --> $DIR/trait-where-clause.rs:10:13
    |
 LL |     fn c<T: ~const Bar>();
-   |             ^^^^^^^^^^
+   |             ^^^^^^
    |
 note: this function is not `const`, so it cannot have `~const` trait bounds
   --> $DIR/trait-where-clause.rs:10:8
diff --git a/tests/ui/stats/hir-stats.stderr b/tests/ui/stats/hir-stats.stderr
index 813e65e45a2..e6da83296ce 100644
--- a/tests/ui/stats/hir-stats.stderr
+++ b/tests/ui/stats/hir-stats.stderr
@@ -21,31 +21,31 @@ ast-stats-1 - Local                     32 ( 0.5%)             1
 ast-stats-1 - MacCall                   32 ( 0.5%)             1
 ast-stats-1 - Expr                      96 ( 1.5%)             3
 ast-stats-1 Param                    160 ( 2.5%)             4            40
-ast-stats-1 Block                    192 ( 3.0%)             6            32
+ast-stats-1 Block                    192 ( 2.9%)             6            32
 ast-stats-1 Variant                  208 ( 3.2%)             2           104
-ast-stats-1 GenericBound             224 ( 3.5%)             4            56
-ast-stats-1 - Trait                    224 ( 3.5%)             4
+ast-stats-1 GenericBound             256 ( 3.9%)             4            64
+ast-stats-1 - Trait                    256 ( 3.9%)             4
 ast-stats-1 AssocItem                352 ( 5.4%)             4            88
 ast-stats-1 - Type                     176 ( 2.7%)             2
 ast-stats-1 - Fn                       176 ( 2.7%)             2
 ast-stats-1 GenericParam             480 ( 7.4%)             5            96
-ast-stats-1 Pat                      504 ( 7.8%)             7            72
+ast-stats-1 Pat                      504 ( 7.7%)             7            72
 ast-stats-1 - Struct                    72 ( 1.1%)             1
 ast-stats-1 - Wild                      72 ( 1.1%)             1
 ast-stats-1 - Ident                    360 ( 5.5%)             5
-ast-stats-1 Expr                     576 ( 8.9%)             8            72
+ast-stats-1 Expr                     576 ( 8.8%)             8            72
 ast-stats-1 - Path                      72 ( 1.1%)             1
 ast-stats-1 - Match                     72 ( 1.1%)             1
 ast-stats-1 - Struct                    72 ( 1.1%)             1
 ast-stats-1 - Lit                      144 ( 2.2%)             2
 ast-stats-1 - Block                    216 ( 3.3%)             3
-ast-stats-1 PathSegment              720 (11.1%)            30            24
-ast-stats-1 Ty                       896 (13.8%)            14            64
+ast-stats-1 PathSegment              720 (11.0%)            30            24
+ast-stats-1 Ty                       896 (13.7%)            14            64
 ast-stats-1 - Ptr                       64 ( 1.0%)             1
 ast-stats-1 - Ref                       64 ( 1.0%)             1
 ast-stats-1 - ImplicitSelf             128 ( 2.0%)             2
-ast-stats-1 - Path                     640 ( 9.9%)            10
-ast-stats-1 Item                   1_224 (18.9%)             9           136
+ast-stats-1 - Path                     640 ( 9.8%)            10
+ast-stats-1 Item                   1_224 (18.8%)             9           136
 ast-stats-1 - Trait                    136 ( 2.1%)             1
 ast-stats-1 - Enum                     136 ( 2.1%)             1
 ast-stats-1 - ForeignMod               136 ( 2.1%)             1
@@ -53,7 +53,7 @@ ast-stats-1 - Impl                     136 ( 2.1%)             1
 ast-stats-1 - Fn                       272 ( 4.2%)             2
 ast-stats-1 - Use                      408 ( 6.3%)             3
 ast-stats-1 ----------------------------------------------------------------
-ast-stats-1 Total                  6_488
+ast-stats-1 Total                  6_520
 ast-stats-1
 ast-stats-2 POST EXPANSION AST STATS
 ast-stats-2 Name                Accumulated Size         Count     Item Size
@@ -65,28 +65,28 @@ ast-stats-2 ExprField                 48 ( 0.7%)             1            48
 ast-stats-2 WherePredicate            56 ( 0.8%)             1            56
 ast-stats-2 - BoundPredicate            56 ( 0.8%)             1
 ast-stats-2 Local                     72 ( 1.0%)             1            72
-ast-stats-2 Arm                       96 ( 1.4%)             2            48
-ast-stats-2 ForeignItem               96 ( 1.4%)             1            96
-ast-stats-2 - Fn                        96 ( 1.4%)             1
+ast-stats-2 Arm                       96 ( 1.3%)             2            48
+ast-stats-2 ForeignItem               96 ( 1.3%)             1            96
+ast-stats-2 - Fn                        96 ( 1.3%)             1
 ast-stats-2 InlineAsm                120 ( 1.7%)             1           120
 ast-stats-2 FnDecl                   120 ( 1.7%)             5            24
 ast-stats-2 Attribute                128 ( 1.8%)             4            32
-ast-stats-2 - DocComment                32 ( 0.5%)             1
-ast-stats-2 - Normal                    96 ( 1.4%)             3
-ast-stats-2 FieldDef                 160 ( 2.3%)             2            80
-ast-stats-2 Stmt                     160 ( 2.3%)             5            32
-ast-stats-2 - Local                     32 ( 0.5%)             1
-ast-stats-2 - Semi                      32 ( 0.5%)             1
-ast-stats-2 - Expr                      96 ( 1.4%)             3
-ast-stats-2 Param                    160 ( 2.3%)             4            40
+ast-stats-2 - DocComment                32 ( 0.4%)             1
+ast-stats-2 - Normal                    96 ( 1.3%)             3
+ast-stats-2 FieldDef                 160 ( 2.2%)             2            80
+ast-stats-2 Stmt                     160 ( 2.2%)             5            32
+ast-stats-2 - Local                     32 ( 0.4%)             1
+ast-stats-2 - Semi                      32 ( 0.4%)             1
+ast-stats-2 - Expr                      96 ( 1.3%)             3
+ast-stats-2 Param                    160 ( 2.2%)             4            40
 ast-stats-2 Block                    192 ( 2.7%)             6            32
 ast-stats-2 Variant                  208 ( 2.9%)             2           104
-ast-stats-2 GenericBound             224 ( 3.2%)             4            56
-ast-stats-2 - Trait                    224 ( 3.2%)             4
-ast-stats-2 AssocItem                352 ( 5.0%)             4            88
+ast-stats-2 GenericBound             256 ( 3.6%)             4            64
+ast-stats-2 - Trait                    256 ( 3.6%)             4
+ast-stats-2 AssocItem                352 ( 4.9%)             4            88
 ast-stats-2 - Type                     176 ( 2.5%)             2
 ast-stats-2 - Fn                       176 ( 2.5%)             2
-ast-stats-2 GenericParam             480 ( 6.8%)             5            96
+ast-stats-2 GenericParam             480 ( 6.7%)             5            96
 ast-stats-2 Pat                      504 ( 7.1%)             7            72
 ast-stats-2 - Struct                    72 ( 1.0%)             1
 ast-stats-2 - Wild                      72 ( 1.0%)             1
@@ -98,22 +98,22 @@ ast-stats-2 - Struct                    72 ( 1.0%)             1
 ast-stats-2 - InlineAsm                 72 ( 1.0%)             1
 ast-stats-2 - Lit                      144 ( 2.0%)             2
 ast-stats-2 - Block                    216 ( 3.0%)             3
-ast-stats-2 PathSegment              792 (11.2%)            33            24
+ast-stats-2 PathSegment              792 (11.1%)            33            24
 ast-stats-2 Ty                       896 (12.6%)            14            64
 ast-stats-2 - Ptr                       64 ( 0.9%)             1
 ast-stats-2 - Ref                       64 ( 0.9%)             1
 ast-stats-2 - ImplicitSelf             128 ( 1.8%)             2
 ast-stats-2 - Path                     640 ( 9.0%)            10
-ast-stats-2 Item                   1_496 (21.1%)            11           136
+ast-stats-2 Item                   1_496 (21.0%)            11           136
 ast-stats-2 - Trait                    136 ( 1.9%)             1
 ast-stats-2 - Enum                     136 ( 1.9%)             1
 ast-stats-2 - ExternCrate              136 ( 1.9%)             1
 ast-stats-2 - ForeignMod               136 ( 1.9%)             1
 ast-stats-2 - Impl                     136 ( 1.9%)             1
 ast-stats-2 - Fn                       272 ( 3.8%)             2
-ast-stats-2 - Use                      544 ( 7.7%)             4
+ast-stats-2 - Use                      544 ( 7.6%)             4
 ast-stats-2 ----------------------------------------------------------------
-ast-stats-2 Total                  7_088
+ast-stats-2 Total                  7_120
 ast-stats-2
 hir-stats HIR STATS
 hir-stats Name                Accumulated Size         Count     Item Size

From 0626de439df0b9bb4e751a92375fdb764c0ee91e Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Fri, 24 Nov 2023 14:51:48 +0000
Subject: [PATCH 64/71] Remove a hack for effects

---
 compiler/rustc_hir_typeck/src/expr.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index a9f67f984da..6d4bd981b7b 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -526,14 +526,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             _ => self.instantiate_value_path(segs, opt_ty, res, expr.span, expr.hir_id).0,
         };
 
-        if let ty::FnDef(did, callee_args) = *ty.kind() {
+        if let ty::FnDef(did, _) = *ty.kind() {
             let fn_sig = ty.fn_sig(tcx);
 
-            // HACK: whenever we get a FnDef in a non-const context, enforce effects to get the
-            // default `host = true` to avoid inference errors later.
-            if tcx.hir().body_const_context(self.body_id).is_none() {
-                self.enforce_context_effects(expr.hir_id, qpath.span(), did, callee_args);
-            }
             if tcx.fn_sig(did).skip_binder().abi() == RustIntrinsic
                 && tcx.item_name(did) == sym::transmute
             {

From 41e8d152dc5abb5a706999ada8b059d3420af8f3 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 15:44:16 +0000
Subject: [PATCH 65/71] Show number in error message even for one error

Co-authored-by: Adrian <adrian.iosdev@gmail.com>
---
 compiler/rustc_errors/src/lib.rs                              | 2 +-
 compiler/rustc_hir_typeck/src/expr.rs                         | 4 ++--
 library/core/src/intrinsics/mir.rs                            | 2 +-
 tests/ui/abi/abi-typo-unstable.stderr                         | 2 +-
 .../ui/alloc-error/alloc-error-handler-bad-signature-3.stderr | 2 +-
 tests/ui/allocator/allocator-args.stderr                      | 2 +-
 tests/ui/allocator/function-allocator.stderr                  | 2 +-
 tests/ui/allocator/two-allocators.stderr                      | 2 +-
 tests/ui/allocator/two-allocators2.stderr                     | 2 +-
 tests/ui/allocator/two-allocators3.stderr                     | 2 +-
 tests/ui/argument-suggestions/complex.stderr                  | 2 +-
 tests/ui/argument-suggestions/display-is-suggestable.stderr   | 2 +-
 tests/ui/argument-suggestions/issue-112507.stderr             | 2 +-
 tests/ui/argument-suggestions/issue-96638.stderr              | 2 +-
 tests/ui/argument-suggestions/issue-97197.stderr              | 2 +-
 tests/ui/argument-suggestions/issue-97484.stderr              | 2 +-
 tests/ui/argument-suggestions/issue-98894.stderr              | 2 +-
 tests/ui/argument-suggestions/issue-98897.stderr              | 2 +-
 tests/ui/argument-suggestions/issue-99482.stderr              | 2 +-
 tests/ui/argument-suggestions/too-long.stderr                 | 2 +-
 tests/ui/argument-suggestions/two-mismatch-notes.stderr       | 2 +-
 tests/ui/array-slice-vec/array_const_index-0.stderr           | 2 +-
 tests/ui/array-slice-vec/array_const_index-1.stderr           | 2 +-
 tests/ui/array-slice-vec/match_arr_unknown_len.stderr         | 2 +-
 tests/ui/array-slice-vec/slice-mut-2.stderr                   | 2 +-
 tests/ui/array-slice-vec/slice-mut.stderr                     | 2 +-
 tests/ui/array-slice-vec/slice-to-vec-comparison.stderr       | 2 +-
 tests/ui/array-slice-vec/vec-macro-with-comma-only.stderr     | 2 +-
 tests/ui/array-slice-vec/vec-mut-iter-borrow.stderr           | 2 +-
 tests/ui/array-slice-vec/vec-res-add.stderr                   | 2 +-
 tests/ui/array-slice-vec/vector-no-ann.stderr                 | 2 +-
 tests/ui/asm/issue-113788.stderr                              | 2 +-
 tests/ui/asm/issue-72570.stderr                               | 2 +-
 tests/ui/asm/issue-85247.rwpi.stderr                          | 2 +-
 tests/ui/asm/issue-87802.stderr                               | 2 +-
 tests/ui/asm/issue-99071.stderr                               | 2 +-
 tests/ui/asm/issue-99122.stderr                               | 2 +-
 tests/ui/asm/reg-conflict.stderr                              | 2 +-
 tests/ui/assign-imm-local-twice.stderr                        | 2 +-
 .../associated-const-ambiguity-report.stderr                  | 2 +-
 tests/ui/associated-consts/associated-const-array-len.stderr  | 2 +-
 tests/ui/associated-consts/associated-const-dead-code.stderr  | 2 +-
 .../associated-const-generic-obligations.stderr               | 2 +-
 .../associated-const-impl-wrong-lifetime.stderr               | 2 +-
 .../associated-consts/associated-const-impl-wrong-type.stderr | 2 +-
 tests/ui/associated-consts/associated-const-in-trait.stderr   | 2 +-
 tests/ui/associated-consts/associated-const-no-item.stderr    | 2 +-
 .../ui/associated-consts/associated-const-private-impl.stderr | 2 +-
 .../associated-const-type-parameter-arrays-2.stderr           | 2 +-
 .../associated-const-type-parameter-arrays.stderr             | 2 +-
 tests/ui/associated-consts/defaults-cyclic-fail.stderr        | 2 +-
 tests/ui/associated-consts/defaults-not-assumed-fail.stderr   | 2 +-
 tests/ui/associated-consts/double-elided.stderr               | 2 +-
 .../infer-placeholder-in-non-suggestable-pos.stderr           | 2 +-
 tests/ui/associated-consts/issue-102335-const.stderr          | 2 +-
 .../issue-24949-assoc-const-static-recursion-impl.stderr      | 2 +-
 ...ue-24949-assoc-const-static-recursion-trait-default.stderr | 2 +-
 .../issue-24949-assoc-const-static-recursion-trait.stderr     | 2 +-
 tests/ui/associated-consts/issue-47814.stderr                 | 2 +-
 .../projection-unspecified-but-bounded.stderr                 | 2 +-
 tests/ui/associated-consts/shadowed-const.stderr              | 2 +-
 tests/ui/associated-inherent-types/ambiguity.stderr           | 2 +-
 .../associated-inherent-types/assoc-inherent-no-body.stderr   | 2 +-
 .../associated-inherent-types/assoc-inherent-unstable.stderr  | 2 +-
 .../bugs/cycle-iat-inside-of-adt.stderr                       | 2 +-
 .../bugs/cycle-iat-inside-of-where-predicate.stderr           | 2 +-
 .../generic-associated-types-bad.local.stderr                 | 2 +-
 .../generic-associated-types-bad.region.stderr                | 2 +-
 tests/ui/associated-inherent-types/inference-fail.stderr      | 2 +-
 tests/ui/associated-inherent-types/issue-109299-1.stderr      | 2 +-
 tests/ui/associated-inherent-types/issue-109299.stderr        | 2 +-
 tests/ui/associated-inherent-types/issue-111404-1.stderr      | 2 +-
 tests/ui/associated-inherent-types/issue-111879-0.stderr      | 2 +-
 tests/ui/associated-inherent-types/issue-111879-1.stderr      | 2 +-
 tests/ui/associated-inherent-types/late-bound-regions.stderr  | 2 +-
 .../associated-inherent-types/normalization-overflow.stderr   | 2 +-
 ...und-self-type-differs-shadowing-trait-item.shadowed.stderr | 2 +-
 ...nd-self-type-differs-shadowing-trait-item.uncovered.stderr | 2 +-
 .../not-found-unsatisfied-bounds-1.stderr                     | 2 +-
 .../not-found-unsatisfied-bounds-in-multiple-impls.stderr     | 2 +-
 tests/ui/associated-inherent-types/regionck-0.stderr          | 2 +-
 tests/ui/associated-inherent-types/regionck-2.stderr          | 2 +-
 tests/ui/associated-inherent-types/style.stderr               | 2 +-
 .../unsatisfied-bounds-inferred-type.stderr                   | 2 +-
 .../unsatisfied-bounds-where-clause-on-assoc-ty.stderr        | 2 +-
 .../ambiguous-associated-type-with-generics.stderr            | 2 +-
 .../associated-item/associated-item-duplicate-bounds.stderr   | 2 +-
 .../associated-item/associated-item-duplicate-names-2.stderr  | 2 +-
 tests/ui/associated-item/impl-duplicate-methods.stderr        | 2 +-
 .../associated-type-bounds/ambiguous-associated-type2.stderr  | 2 +-
 .../assoc-type-eq-with-dyn-atb-fail.stderr                    | 2 +-
 .../bad-universal-in-dyn-in-where-clause.stderr               | 2 +-
 .../associated-type-bounds/bad-universal-in-impl-sig.stderr   | 2 +-
 tests/ui/associated-type-bounds/binder-on-bound.stderr        | 2 +-
 .../ui/associated-type-bounds/const-projection-err.gce.stderr | 2 +-
 .../associated-type-bounds/const-projection-err.stock.stderr  | 2 +-
 tests/ui/associated-type-bounds/consts.stderr                 | 2 +-
 ...-in-suggestion-for-type-param-of-current-assoc-item.stderr | 2 +-
 tests/ui/associated-type-bounds/issue-102335-ty.stderr        | 2 +-
 tests/ui/associated-type-bounds/issue-104916.stderr           | 2 +-
 tests/ui/associated-type-bounds/issue-71443-1.stderr          | 2 +-
 .../return-type-notation/basic.without.stderr                 | 2 +-
 .../return-type-notation/equality.stderr                      | 2 +-
 .../return-type-notation/missing.stderr                       | 2 +-
 .../return-type-notation/non-rpitit.stderr                    | 2 +-
 .../return-type-notation/unpretty-parenthesized.stderr        | 2 +-
 ...ggest-contraining-assoc-type-because-of-assoc-const.stderr | 2 +-
 tests/ui/associated-types/associated-type-macro.stderr        | 2 +-
 .../associated-types-ICE-when-projecting-out-of-err.stderr    | 2 +-
 .../ui/associated-types/associated-types-bound-failure.stderr | 2 +-
 tests/ui/associated-types/associated-types-eq-1.stderr        | 2 +-
 tests/ui/associated-types/associated-types-eq-2.stderr        | 2 +-
 .../ui/associated-types/associated-types-eq-expr-path.stderr  | 2 +-
 .../associated-types/associated-types-for-unimpl-trait.stderr | 2 +-
 .../associated-types-invalid-trait-ref-issue-18865.stderr     | 2 +-
 tests/ui/associated-types/associated-types-issue-17359.stderr | 2 +-
 tests/ui/associated-types/associated-types-issue-20346.stderr | 2 +-
 .../associated-types-no-suitable-bound.stderr                 | 2 +-
 .../associated-types-no-suitable-supertrait-2.stderr          | 2 +-
 tests/ui/associated-types/associated-types-outlives.stderr    | 2 +-
 .../associated-types-overridden-binding-2.stderr              | 2 +-
 .../associated-types-project-from-hrtb-in-fn.stderr           | 2 +-
 ...ection-to-unrelated-trait-in-method-without-default.stderr | 2 +-
 .../ui/associated-types/associated-types-unconstrained.stderr | 2 +-
 tests/ui/associated-types/associated-types-unsized.stderr     | 2 +-
 .../bound-lifetime-in-binding-only.elision.stderr             | 2 +-
 .../associated-types/bound-lifetime-in-binding-only.ok.stderr | 2 +-
 .../bound-lifetime-in-return-only.elision.stderr              | 2 +-
 .../bound-lifetime-in-return-only.local.stderr                | 2 +-
 .../associated-types/bound-lifetime-in-return-only.ok.stderr  | 2 +-
 .../bound-lifetime-in-return-only.structure.stderr            | 2 +-
 .../cache/project-fn-ret-contravariant.transmute.stderr       | 2 +-
 .../cache/project-fn-ret-invariant.transmute.stderr           | 2 +-
 tests/ui/associated-types/defaults-wf.stderr                  | 2 +-
 .../ui/associated-types/dont-suggest-cyclic-constraint.stderr | 2 +-
 tests/ui/associated-types/higher-ranked-projection.bad.stderr | 2 +-
 tests/ui/associated-types/hr-associated-type-bound-1.stderr   | 2 +-
 tests/ui/associated-types/hr-associated-type-bound-2.stderr   | 2 +-
 .../associated-types/hr-associated-type-bound-object.stderr   | 2 +-
 .../associated-types/hr-associated-type-bound-param-1.stderr  | 2 +-
 .../associated-types/hr-associated-type-bound-param-3.stderr  | 2 +-
 .../associated-types/hr-associated-type-bound-param-4.stderr  | 2 +-
 .../associated-types/hr-associated-type-bound-param-6.stderr  | 2 +-
 .../associated-types/hr-associated-type-projection-1.stderr   | 2 +-
 .../impl-trait-return-missing-constraint.stderr               | 2 +-
 tests/ui/associated-types/impl-wf-cycle-1.stderr              | 2 +-
 tests/ui/associated-types/impl-wf-cycle-2.stderr              | 2 +-
 tests/ui/associated-types/issue-19883.stderr                  | 2 +-
 tests/ui/associated-types/issue-20005.stderr                  | 2 +-
 tests/ui/associated-types/issue-20825.stderr                  | 2 +-
 tests/ui/associated-types/issue-22037.stderr                  | 2 +-
 tests/ui/associated-types/issue-23595-1.stderr                | 2 +-
 tests/ui/associated-types/issue-23595-2.stderr                | 2 +-
 tests/ui/associated-types/issue-25700.stderr                  | 2 +-
 tests/ui/associated-types/issue-26681.stderr                  | 2 +-
 tests/ui/associated-types/issue-27675-unchecked-bounds.stderr | 2 +-
 tests/ui/associated-types/issue-32323.stderr                  | 2 +-
 tests/ui/associated-types/issue-36499.rs                      | 2 +-
 tests/ui/associated-types/issue-36499.stderr                  | 2 +-
 tests/ui/associated-types/issue-38821.stderr                  | 2 +-
 tests/ui/associated-types/issue-43784-associated-type.stderr  | 2 +-
 tests/ui/associated-types/issue-44153.stderr                  | 2 +-
 tests/ui/associated-types/issue-47814.stderr                  | 2 +-
 tests/ui/associated-types/issue-54108.stderr                  | 2 +-
 tests/ui/associated-types/issue-62200.stderr                  | 2 +-
 tests/ui/associated-types/issue-63593.stderr                  | 2 +-
 tests/ui/associated-types/issue-64855.stderr                  | 2 +-
 tests/ui/associated-types/issue-72806.stderr                  | 2 +-
 tests/ui/associated-types/issue-85103-layout-debug.stderr     | 2 +-
 .../point-at-type-on-obligation-failure.stderr                | 2 +-
 .../trait-with-supertraits-needing-sized-self.stderr          | 2 +-
 .../async-await/async-borrowck-escaping-closure-error.stderr  | 2 +-
 tests/ui/async-await/async-fn-path-elision.stderr             | 2 +-
 tests/ui/async-await/async-is-unwindsafe.stderr               | 2 +-
 .../ui/async-await/await-keyword/post_expansion_error.stderr  | 2 +-
 tests/ui/async-await/awaiting-unsized-param.stderr            | 2 +-
 tests/ui/async-await/clone-suggestion.stderr                  | 2 +-
 tests/ui/async-await/const-async-fn-in-main.stderr            | 2 +-
 tests/ui/async-await/dont-print-desugared-async.stderr        | 2 +-
 .../dont-suggest-await-on-method-return-mismatch.stderr       | 2 +-
 tests/ui/async-await/dont-suggest-missing-await.stderr        | 2 +-
 tests/ui/async-await/drop-track-field-assign-nonsend.stderr   | 2 +-
 tests/ui/async-await/feature-async-closure.stderr             | 2 +-
 tests/ui/async-await/feature-self-return-type.stderr          | 2 +-
 tests/ui/async-await/field-assign-nonsend.stderr              | 2 +-
 tests/ui/async-await/future-contains-err-issue-115188.stderr  | 2 +-
 .../in-trait/async-example-desugared-boxed-in-trait.stderr    | 2 +-
 .../async-await/in-trait/async-example-desugared-boxed.stderr | 2 +-
 .../in-trait/async-example-desugared-manual.stderr            | 2 +-
 tests/ui/async-await/in-trait/async-recursive-generic.stderr  | 2 +-
 tests/ui/async-await/in-trait/async-recursive.stderr          | 2 +-
 tests/ui/async-await/in-trait/fn-not-async-err.stderr         | 2 +-
 tests/ui/async-await/in-trait/generics-mismatch.stderr        | 2 +-
 .../in-trait/indirect-recursion-issue-112047.stderr           | 2 +-
 tests/ui/async-await/in-trait/lifetime-mismatch.stderr        | 2 +-
 tests/ui/async-await/in-trait/missing-send-bound.stderr       | 2 +-
 tests/ui/async-await/in-trait/object-safety.stderr            | 2 +-
 .../in-trait/return-not-existing-type-wrapping-rpitit.stderr  | 2 +-
 tests/ui/async-await/in-trait/return-type-suggestion.stderr   | 2 +-
 .../in-trait/send-on-foreign-async-fn-in-trait.stderr         | 2 +-
 .../ui/async-await/in-trait/unconstrained-impl-region.stderr  | 2 +-
 tests/ui/async-await/in-trait/warn.stderr                     | 2 +-
 .../async-await/incorrect-move-async-order-issue-79694.stderr | 2 +-
 tests/ui/async-await/issue-101715.stderr                      | 2 +-
 tests/ui/async-await/issue-108572.stderr                      | 2 +-
 tests/ui/async-await/issue-64130-1-sync.stderr                | 2 +-
 tests/ui/async-await/issue-64130-2-send.stderr                | 2 +-
 tests/ui/async-await/issue-64130-3-other.stderr               | 2 +-
 tests/ui/async-await/issue-64130-non-send-future-diags.stderr | 2 +-
 tests/ui/async-await/issue-66387-if-without-else.stderr       | 2 +-
 tests/ui/async-await/issue-67252-unnamed-future.stderr        | 2 +-
 tests/ui/async-await/issue-67651.stderr                       | 2 +-
 tests/ui/async-await/issue-67765-async-diagnostic.stderr      | 2 +-
 tests/ui/async-await/issue-68523-start.stderr                 | 2 +-
 tests/ui/async-await/issue-68523.stderr                       | 2 +-
 tests/ui/async-await/issue-69446-fnmut-capture.stderr         | 2 +-
 tests/ui/async-await/issue-70818.stderr                       | 2 +-
 tests/ui/async-await/issue-70935-complex-spans.stderr         | 2 +-
 tests/ui/async-await/issue-71137.stderr                       | 2 +-
 tests/ui/async-await/issue-72442.stderr                       | 2 +-
 tests/ui/async-await/issue-73541-1.stderr                     | 2 +-
 tests/ui/async-await/issue-73541-2.stderr                     | 2 +-
 tests/ui/async-await/issue-73541-3.stderr                     | 2 +-
 tests/ui/async-await/issue-73541.stderr                       | 2 +-
 tests/ui/async-await/issue-73741-type-err.stderr              | 2 +-
 tests/ui/async-await/issue-74047.stderr                       | 2 +-
 tests/ui/async-await/issue-74497-lifetime-in-opaque.stderr    | 2 +-
 .../ui/async-await/issue-75785-confusing-named-region.stderr  | 2 +-
 tests/ui/async-await/issue-77993-2.stderr                     | 2 +-
 tests/ui/async-await/issue-86507.stderr                       | 2 +-
 tests/ui/async-await/issues/issue-102206.stderr               | 2 +-
 tests/ui/async-await/issues/issue-107280.stderr               | 2 +-
 tests/ui/async-await/issues/issue-112225-2.stderr             | 2 +-
 tests/ui/async-await/issues/issue-51719.stderr                | 2 +-
 tests/ui/async-await/issues/issue-51751.stderr                | 2 +-
 tests/ui/async-await/issues/issue-61187.stderr                | 2 +-
 tests/ui/async-await/issues/issue-62009-2.stderr              | 2 +-
 tests/ui/async-await/issues/issue-63388-1.stderr              | 2 +-
 tests/ui/async-await/issues/issue-65159.stderr                | 2 +-
 .../issues/issue-66958-non-copy-infered-type-arg.stderr       | 2 +-
 tests/ui/async-await/issues/issue-67893.stderr                | 2 +-
 tests/ui/async-await/issues/issue-72312.stderr                | 2 +-
 tests/ui/async-await/issues/issue-78938-async-block.stderr    | 2 +-
 tests/ui/async-await/issues/non-async-enclosing-span.stderr   | 2 +-
 tests/ui/async-await/no-const-async.stderr                    | 2 +-
 tests/ui/async-await/no-move-across-await-struct.stderr       | 2 +-
 tests/ui/async-await/no-move-across-await-tuple.stderr        | 2 +-
 tests/ui/async-await/no-non-guaranteed-initialization.stderr  | 2 +-
 tests/ui/async-await/no-params-non-move-async-closure.stderr  | 2 +-
 tests/ui/async-await/partial-drop-partial-reinit.stderr       | 2 +-
 tests/ui/async-await/pin-needed-to-poll-2.stderr              | 2 +-
 tests/ui/async-await/pin-needed-to-poll.stderr                | 2 +-
 tests/ui/async-await/proper-span-for-type-error.stderr        | 2 +-
 tests/ui/async-await/recursive-async-impl-trait-type.stderr   | 2 +-
 .../normalizing-self-auto-trait-issue-109924.current.stderr   | 2 +-
 .../return-type-notation/rtn-in-impl-signature.stderr         | 2 +-
 .../return-type-notation/super-method-bound-ambig.stderr      | 2 +-
 tests/ui/async-await/suggest-missing-await-closure.stderr     | 2 +-
 tests/ui/async-await/unreachable-lint-1.stderr                | 2 +-
 tests/ui/async-await/unresolved_type_param.stderr             | 2 +-
 tests/ui/async-await/unsized-across-await.stderr              | 2 +-
 tests/ui/attr-bad-crate-attr.stderr                           | 2 +-
 tests/ui/attributes/attr-eq-token-tree.stderr                 | 2 +-
 tests/ui/attributes/attrs-with-no-formal-in-generics-1.stderr | 2 +-
 tests/ui/attributes/attrs-with-no-formal-in-generics-2.stderr | 2 +-
 tests/ui/attributes/attrs-with-no-formal-in-generics-3.stderr | 2 +-
 tests/ui/attributes/doc-test-literal.stderr                   | 2 +-
 tests/ui/attributes/extented-attribute-macro-error.stderr     | 2 +-
 tests/ui/attributes/invalid-repr.stderr                       | 2 +-
 tests/ui/attributes/issue-100631.stderr                       | 2 +-
 tests/ui/attributes/key-value-expansion-on-mac.stderr         | 2 +-
 tests/ui/attributes/key-value-non-ascii.stderr                | 2 +-
 tests/ui/attributes/macro_export_on_decl_macro.stderr         | 2 +-
 tests/ui/attributes/main-removed-1.stderr                     | 2 +-
 tests/ui/attributes/no-mangle-closure.stderr                  | 2 +-
 tests/ui/attributes/unix_sigpipe/unix_sigpipe-crate.stderr    | 2 +-
 .../ui/attributes/unix_sigpipe/unix_sigpipe-duplicates.stderr | 2 +-
 tests/ui/attributes/unix_sigpipe/unix_sigpipe-list.stderr     | 2 +-
 .../attributes/unix_sigpipe/unix_sigpipe-non-main-fn.stderr   | 2 +-
 .../attributes/unix_sigpipe/unix_sigpipe-non-root-main.stderr | 2 +-
 tests/ui/attributes/unix_sigpipe/unix_sigpipe-start.stderr    | 2 +-
 tests/ui/attributes/unix_sigpipe/unix_sigpipe-struct.stderr   | 2 +-
 tests/ui/attributes/unix_sigpipe/unix_sigpipe-wrong.stderr    | 2 +-
 tests/ui/attributes/unix_sigpipe/unix_sigpipe.stderr          | 2 +-
 tests/ui/attributes/used_with_multi_args.stderr               | 2 +-
 tests/ui/auto-traits/bad-generics-on-dyn.stderr               | 2 +-
 tests/ui/auto-traits/has-arguments.stderr                     | 2 +-
 tests/ui/auto-traits/issue-23080-2.current.stderr             | 2 +-
 tests/ui/auto-traits/issue-23080-2.next.stderr                | 2 +-
 tests/ui/auto-traits/issue-23080.stderr                       | 2 +-
 tests/ui/auto-traits/issue-83857-ub.stderr                    | 2 +-
 tests/ui/auto-traits/issue-84075.stderr                       | 2 +-
 tests/ui/auto-traits/str-contains-slice-conceptually.stderr   | 2 +-
 tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr  | 2 +-
 .../typeck-default-trait-impl-constituent-types-2.stderr      | 2 +-
 .../typeck-default-trait-impl-constituent-types.stderr        | 2 +-
 .../auto-traits/typeck-default-trait-impl-precedence.stderr   | 2 +-
 .../deref-ambiguity-becomes-nonambiguous.stderr               | 2 +-
 tests/ui/binding/const-param.stderr                           | 2 +-
 tests/ui/binop/binary-op-on-double-ref.stderr                 | 2 +-
 tests/ui/binop/binary-op-suggest-deref.stderr                 | 2 +-
 tests/ui/binop/binop-bitxor-str.stderr                        | 2 +-
 tests/ui/binop/binop-mul-bool.stderr                          | 2 +-
 tests/ui/binop/binop-mul-i32-f32.stderr                       | 2 +-
 tests/ui/binop/binop-typeck.stderr                            | 2 +-
 tests/ui/binop/eq-arr.stderr                                  | 2 +-
 tests/ui/binop/eq-vec.stderr                                  | 2 +-
 tests/ui/binop/false-binop-caused-by-missing-semi.stderr      | 2 +-
 tests/ui/binop/issue-3820.stderr                              | 2 +-
 tests/ui/binop/issue-77910-2.stderr                           | 2 +-
 tests/ui/binop/issue-93927.stderr                             | 2 +-
 tests/ui/binop/placement-syntax.stderr                        | 2 +-
 tests/ui/blind/blind-item-block-item-shadow.stderr            | 2 +-
 tests/ui/blind/blind-item-block-middle.stderr                 | 2 +-
 tests/ui/blind/blind-item-item-shadow.stderr                  | 2 +-
 tests/ui/block-result/block-must-not-have-result-do.stderr    | 2 +-
 tests/ui/block-result/block-must-not-have-result-res.stderr   | 2 +-
 tests/ui/block-result/block-must-not-have-result-while.stderr | 2 +-
 tests/ui/block-result/issue-11714.stderr                      | 2 +-
 tests/ui/block-result/issue-3563.stderr                       | 2 +-
 tests/ui/block-result/issue-5500.stderr                       | 2 +-
 tests/ui/block-result/unexpected-return-on-unit.stderr        | 2 +-
 tests/ui/bogus-tag.stderr                                     | 2 +-
 tests/ui/borrowck/access-mode-in-closures.stderr              | 2 +-
 tests/ui/borrowck/alias-liveness/escaping-bounds-2.stderr     | 2 +-
 .../alias-liveness/higher-ranked-outlives-for-capture.stderr  | 2 +-
 tests/ui/borrowck/alias-liveness/opaque-type-param.stderr     | 2 +-
 tests/ui/borrowck/anonymous-region-in-apit.stderr             | 2 +-
 .../borrow-immutable-upvar-mutation-impl-trait.stderr         | 2 +-
 tests/ui/borrowck/borrowck-and-init.stderr                    | 2 +-
 tests/ui/borrowck/borrowck-anon-fields-struct.stderr          | 2 +-
 tests/ui/borrowck/borrowck-anon-fields-tuple.stderr           | 2 +-
 tests/ui/borrowck/borrowck-assign-to-constants.stderr         | 2 +-
 tests/ui/borrowck/borrowck-auto-mut-ref-to-immut-var.stderr   | 2 +-
 tests/ui/borrowck/borrowck-autoref-3261.stderr                | 2 +-
 tests/ui/borrowck/borrowck-block-uninit.stderr                | 2 +-
 tests/ui/borrowck/borrowck-borrow-from-temporary.stderr       | 2 +-
 .../borrowck/borrowck-borrow-immut-deref-of-box-as-mut.stderr | 2 +-
 tests/ui/borrowck/borrowck-borrow-mut-object-twice.stderr     | 2 +-
 tests/ui/borrowck/borrowck-borrowed-uniq-rvalue-2.stderr      | 2 +-
 tests/ui/borrowck/borrowck-borrowed-uniq-rvalue.stderr        | 2 +-
 tests/ui/borrowck/borrowck-break-uninit-2.stderr              | 2 +-
 tests/ui/borrowck/borrowck-break-uninit.stderr                | 2 +-
 tests/ui/borrowck/borrowck-closures-mut-of-mut.stderr         | 2 +-
 tests/ui/borrowck/borrowck-closures-unique-imm.stderr         | 2 +-
 tests/ui/borrowck/borrowck-closures-use-after-free.stderr     | 2 +-
 tests/ui/borrowck/borrowck-consume-unsize-vec.stderr          | 2 +-
 tests/ui/borrowck/borrowck-consume-upcast-box.stderr          | 2 +-
 tests/ui/borrowck/borrowck-escaping-closure-error-1.stderr    | 2 +-
 tests/ui/borrowck/borrowck-escaping-closure-error-2.stderr    | 2 +-
 tests/ui/borrowck/borrowck-fn-in-const-a.stderr               | 2 +-
 tests/ui/borrowck/borrowck-fn-in-const-c.stderr               | 2 +-
 .../borrowck/borrowck-for-loop-uninitialized-binding.stderr   | 2 +-
 tests/ui/borrowck/borrowck-if-no-else.stderr                  | 2 +-
 tests/ui/borrowck/borrowck-if-with-else.stderr                | 2 +-
 .../borrowck-imm-ref-to-mut-rec-field-issue-3162-c.stderr     | 2 +-
 tests/ui/borrowck/borrowck-in-static.stderr                   | 2 +-
 tests/ui/borrowck/borrowck-init-in-called-fn-expr.stderr      | 2 +-
 tests/ui/borrowck/borrowck-init-in-fn-expr.stderr             | 2 +-
 tests/ui/borrowck/borrowck-init-in-fru.stderr                 | 2 +-
 tests/ui/borrowck/borrowck-init-op-equal.stderr               | 2 +-
 tests/ui/borrowck/borrowck-init-plus-equal.stderr             | 2 +-
 tests/ui/borrowck/borrowck-issue-2657-1.stderr                | 2 +-
 tests/ui/borrowck/borrowck-issue-2657-2.stderr                | 2 +-
 tests/ui/borrowck/borrowck-lend-flow-if.stderr                | 2 +-
 tests/ui/borrowck/borrowck-lend-flow-match.stderr             | 2 +-
 tests/ui/borrowck/borrowck-lend-flow.stderr                   | 2 +-
 tests/ui/borrowck/borrowck-loan-blocks-move.stderr            | 2 +-
 tests/ui/borrowck/borrowck-loan-blocks-mut-uniq.stderr        | 2 +-
 tests/ui/borrowck/borrowck-loan-in-overloaded-op.stderr       | 2 +-
 .../borrowck/borrowck-loan-of-static-data-issue-27616.stderr  | 2 +-
 tests/ui/borrowck/borrowck-loan-vec-content.stderr            | 2 +-
 tests/ui/borrowck/borrowck-local-borrow-outlives-fn.stderr    | 2 +-
 .../borrowck-local-borrow-with-panic-outlives-fn.stderr       | 2 +-
 tests/ui/borrowck/borrowck-move-by-capture.stderr             | 2 +-
 .../borrowck-move-from-subpath-of-borrowed-path.stderr        | 2 +-
 tests/ui/borrowck/borrowck-move-from-unsafe-ptr.stderr        | 2 +-
 .../ui/borrowck/borrowck-move-moved-value-into-closure.stderr | 2 +-
 tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr           | 2 +-
 .../borrowck-move-out-of-overloaded-auto-deref.stderr         | 2 +-
 .../ui/borrowck/borrowck-move-out-of-overloaded-deref.stderr  | 2 +-
 tests/ui/borrowck/borrowck-move-out-of-static-item.stderr     | 2 +-
 tests/ui/borrowck/borrowck-move-out-of-vec-tail.stderr        | 2 +-
 tests/ui/borrowck/borrowck-move-subcomponent.stderr           | 2 +-
 tests/ui/borrowck/borrowck-mut-addr-of-imm-var.stderr         | 2 +-
 tests/ui/borrowck/borrowck-mut-slice-of-imm-vec.stderr        | 2 +-
 tests/ui/borrowck/borrowck-no-cycle-in-exchange-heap.stderr   | 2 +-
 tests/ui/borrowck/borrowck-or-init.stderr                     | 2 +-
 .../borrowck-overloaded-index-and-overloaded-deref.stderr     | 2 +-
 .../borrowck/borrowck-overloaded-index-move-from-vec.stderr   | 2 +-
 tests/ui/borrowck/borrowck-partial-reinit-2.stderr            | 2 +-
 tests/ui/borrowck/borrowck-partial-reinit-3.stderr            | 2 +-
 tests/ui/borrowck/borrowck-partial-reinit-4.stderr            | 2 +-
 tests/ui/borrowck/borrowck-pat-reassign-binding.stderr        | 2 +-
 .../borrowck-reborrow-from-shorter-lived-andmut.stderr        | 2 +-
 tests/ui/borrowck/borrowck-ref-mut-of-imm.stderr              | 2 +-
 tests/ui/borrowck/borrowck-reinit.stderr                      | 2 +-
 .../borrowck-return-variable-on-stack-via-clone.stderr        | 2 +-
 tests/ui/borrowck/borrowck-return.stderr                      | 2 +-
 tests/ui/borrowck/borrowck-storage-dead.stderr                | 2 +-
 tests/ui/borrowck/borrowck-swap-mut-base-ptr.stderr           | 2 +-
 .../borrowck-thread-local-static-borrow-outlives-fn.stderr    | 2 +-
 tests/ui/borrowck/borrowck-unary-move.stderr                  | 2 +-
 tests/ui/borrowck/borrowck-uninit-after-item.stderr           | 2 +-
 tests/ui/borrowck/borrowck-uninit.stderr                      | 2 +-
 tests/ui/borrowck/borrowck-union-borrow-nested.stderr         | 2 +-
 tests/ui/borrowck/borrowck-union-move-assign.stderr           | 2 +-
 .../borrowck/borrowck-use-uninitialized-in-cast-trait.stderr  | 2 +-
 tests/ui/borrowck/borrowck-use-uninitialized-in-cast.stderr   | 2 +-
 tests/ui/borrowck/borrowck-vec-pattern-loan-from-mut.stderr   | 2 +-
 tests/ui/borrowck/borrowck-vec-pattern-move-tail.stderr       | 2 +-
 .../ui/borrowck/borrowck-vec-pattern-tail-element-loan.stderr | 2 +-
 tests/ui/borrowck/borrowck-while-break.stderr                 | 2 +-
 tests/ui/borrowck/borrowck-while-cond.stderr                  | 2 +-
 tests/ui/borrowck/borrowck-while.stderr                       | 2 +-
 tests/ui/borrowck/clone-span-on-try-operator.stderr           | 2 +-
 tests/ui/borrowck/copy-suggestion-region-vid.stderr           | 2 +-
 ...-adding-move-when-closure-is-already-marked-as-move.stderr | 2 +-
 tests/ui/borrowck/drop-in-loop.stderr                         | 2 +-
 tests/ui/borrowck/immutable-arg.stderr                        | 2 +-
 tests/ui/borrowck/index-mut-help-with-impl.stderr             | 2 +-
 tests/ui/borrowck/issue-101119.stderr                         | 2 +-
 tests/ui/borrowck/issue-103250.stderr                         | 2 +-
 tests/ui/borrowck/issue-11493.stderr                          | 2 +-
 tests/ui/borrowck/issue-115259-suggest-iter-mut.stderr        | 2 +-
 tests/ui/borrowck/issue-17545.stderr                          | 2 +-
 tests/ui/borrowck/issue-17718-static-move.stderr              | 2 +-
 tests/ui/borrowck/issue-25793.stderr                          | 2 +-
 tests/ui/borrowck/issue-33819.stderr                          | 2 +-
 tests/ui/borrowck/issue-36082.stderr                          | 2 +-
 tests/ui/borrowck/issue-41962.stderr                          | 2 +-
 tests/ui/borrowck/issue-42344.stderr                          | 2 +-
 tests/ui/borrowck/issue-45983.stderr                          | 2 +-
 tests/ui/borrowck/issue-46471.stderr                          | 2 +-
 tests/ui/borrowck/issue-47215-ice-from-drop-elab.stderr       | 2 +-
 tests/ui/borrowck/issue-47646.stderr                          | 2 +-
 tests/ui/borrowck/issue-51117.stderr                          | 2 +-
 tests/ui/borrowck/issue-51301.stderr                          | 2 +-
 tests/ui/borrowck/issue-51415.stderr                          | 2 +-
 tests/ui/borrowck/issue-52713-bug.stderr                      | 2 +-
 .../issue-53432-nested-closure-outlives-borrowed-value.stderr | 2 +-
 .../issue-54597-reject-move-out-of-borrow-via-pat.stderr      | 2 +-
 tests/ui/borrowck/issue-58776-borrowck-scans-children.stderr  | 2 +-
 tests/ui/borrowck/issue-62107-match-arm-scopes.stderr         | 2 +-
 tests/ui/borrowck/issue-62387-suggest-iter-mut-2.stderr       | 2 +-
 tests/ui/borrowck/issue-69789-iterator-mut-suggestion.stderr  | 2 +-
 tests/ui/borrowck/issue-7573.stderr                           | 2 +-
 tests/ui/borrowck/issue-81365-1.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-10.stderr                       | 2 +-
 tests/ui/borrowck/issue-81365-11.stderr                       | 2 +-
 tests/ui/borrowck/issue-81365-2.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-3.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-4.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-5.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-6.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-7.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-8.stderr                        | 2 +-
 tests/ui/borrowck/issue-81365-9.stderr                        | 2 +-
 tests/ui/borrowck/issue-81899.stderr                          | 2 +-
 tests/ui/borrowck/issue-82032.stderr                          | 2 +-
 tests/ui/borrowck/issue-82462.stderr                          | 2 +-
 tests/ui/borrowck/issue-83309-ice-immut-in-for-loop.stderr    | 2 +-
 tests/ui/borrowck/issue-83924.stderr                          | 2 +-
 tests/ui/borrowck/issue-85581.stderr                          | 2 +-
 tests/ui/borrowck/issue-87456-point-to-closure.stderr         | 2 +-
 tests/ui/borrowck/issue-88434-minimal-example.stderr          | 2 +-
 .../borrowck/issue-88434-removal-index-should-be-less.stderr  | 2 +-
 tests/ui/borrowck/issue-91206.stderr                          | 2 +-
 tests/ui/borrowck/issue-92015.stderr                          | 2 +-
 tests/ui/borrowck/issue-92157.stderr                          | 2 +-
 tests/ui/borrowck/issue-93078.stderr                          | 2 +-
 tests/ui/borrowck/issue-93093.stderr                          | 2 +-
 tests/ui/borrowck/many-mutable-borrows.stderr                 | 2 +-
 tests/ui/borrowck/move-error-in-promoted-2.stderr             | 2 +-
 tests/ui/borrowck/move-error-in-promoted.stderr               | 2 +-
 tests/ui/borrowck/move-error-snippets.stderr                  | 2 +-
 tests/ui/borrowck/move-in-pattern-mut-in-loop.stderr          | 2 +-
 tests/ui/borrowck/mut-borrow-in-loop-2.stderr                 | 2 +-
 tests/ui/borrowck/reborrow-sugg-move-then-borrow.stderr       | 2 +-
 tests/ui/borrowck/regions-escape-bound-fn-2.stderr            | 2 +-
 tests/ui/borrowck/regions-escape-bound-fn.stderr              | 2 +-
 tests/ui/borrowck/regions-escape-unboxed-closure.stderr       | 2 +-
 tests/ui/borrowck/return-local-binding-from-desugaring.stderr | 2 +-
 tests/ui/borrowck/suggest-local-var-for-vector.stderr         | 2 +-
 tests/ui/borrowck/suggest-mut-iterator.stderr                 | 2 +-
 tests/ui/borrowck/suggest-storing-local-var-for-vector.stderr | 2 +-
 tests/ui/borrowck/tainted-promoteds.stderr                    | 2 +-
 tests/ui/borrowck/two-phase-across-loop.stderr                | 2 +-
 tests/ui/borrowck/two-phase-cannot-nest-mut-self-calls.stderr | 2 +-
 ...o-phase-reservation-sharing-interference.nll_target.stderr | 2 +-
 tests/ui/borrowck/two-phase-sneaky.stderr                     | 2 +-
 ...boxed-closures-move-upvar-from-non-once-ref-closure.stderr | 2 +-
 tests/ui/box/alloc-unstable-fail.stderr                       | 2 +-
 tests/ui/box/issue-82446.stderr                               | 2 +-
 tests/ui/box/leak-alloc.stderr                                | 2 +-
 tests/ui/box/unit/unique-object-noncopyable.stderr            | 2 +-
 tests/ui/box/unit/unique-pinned-nocopy.stderr                 | 2 +-
 tests/ui/btreemap/btreemap-index-mut-2.stderr                 | 2 +-
 tests/ui/btreemap/btreemap-index-mut.stderr                   | 2 +-
 tests/ui/btreemap/btreemap_dropck.stderr                      | 2 +-
 .../builtin-superkinds/builtin-superkinds-in-metadata.stderr  | 2 +-
 .../ui/builtin-superkinds/builtin-superkinds-self-type.stderr | 2 +-
 tests/ui/builtin-superkinds/builtin-superkinds-simple.stderr  | 2 +-
 .../builtin-superkinds-typaram-not-send.stderr                | 2 +-
 tests/ui/c-variadic/issue-32201.stderr                        | 2 +-
 tests/ui/c-variadic/issue-86053-2.stderr                      | 2 +-
 tests/ui/c-variadic/variadic-ffi-2.stderr                     | 2 +-
 tests/ui/c-variadic/variadic-ffi-6.stderr                     | 2 +-
 tests/ui/c-variadic/variadic-ffi-no-fixed-args.stderr         | 2 +-
 tests/ui/capture1.stderr                                      | 2 +-
 tests/ui/cast/cast-errors-issue-43825.stderr                  | 2 +-
 tests/ui/cast/cast-from-nil.stderr                            | 2 +-
 tests/ui/cast/cast-macro-lhs.stderr                           | 2 +-
 tests/ui/cast/cast-rfc0401-2.stderr                           | 2 +-
 tests/ui/cast/cast-to-nil.stderr                              | 2 +-
 tests/ui/cast/casts-differing-anon.stderr                     | 2 +-
 tests/ui/cast/casts-issue-46365.stderr                        | 2 +-
 tests/ui/cast/issue-10991.stderr                              | 2 +-
 tests/ui/cast/issue-17444.stderr                              | 2 +-
 tests/ui/cast/issue-85586.stderr                              | 2 +-
 tests/ui/cast/issue-88621.stderr                              | 2 +-
 tests/ui/cast/issue-89497.stderr                              | 2 +-
 tests/ui/cast/unsized-struct-cast.stderr                      | 2 +-
 tests/ui/cast/unsupported-cast.stderr                         | 2 +-
 tests/ui/cenum_impl_drop_cast.stderr                          | 2 +-
 tests/ui/cfg/diagnostics-not-a-def.stderr                     | 2 +-
 tests/ui/check-static-immutable-mut-slices.stderr             | 2 +-
 tests/ui/class-cast-to-trait.stderr                           | 2 +-
 tests/ui/class-method-missing.stderr                          | 2 +-
 .../expect-infer-var-appearing-twice.stderr                   | 2 +-
 .../expect-two-infer-vars-supply-ty-with-bound-region.stderr  | 2 +-
 tests/ui/closure_context/issue-26046-fn-mut.stderr            | 2 +-
 tests/ui/closure_context/issue-26046-fn-once.stderr           | 2 +-
 tests/ui/closure_context/issue-42065.stderr                   | 2 +-
 .../diagnostics/borrowck/borrowck-1.stderr                    | 2 +-
 .../diagnostics/borrowck/borrowck-2.stderr                    | 2 +-
 .../diagnostics/borrowck/borrowck-3.stderr                    | 2 +-
 .../diagnostics/borrowck/borrowck-4.stderr                    | 2 +-
 .../diagnostics/borrowck/borrowck-closures-mut-and-imm.stderr | 2 +-
 .../diagnostics/cant-mutate-imm-borrow.stderr                 | 2 +-
 .../diagnostics/closure-origin-array-diagnostics.stderr       | 2 +-
 .../closure-origin-multi-variant-diagnostics.stderr           | 2 +-
 .../closure-origin-single-variant-diagnostics.stderr          | 2 +-
 .../diagnostics/closure-origin-struct-diagnostics.stderr      | 2 +-
 .../diagnostics/closure-origin-tuple-diagnostics-1.stderr     | 2 +-
 .../diagnostics/closure-origin-tuple-diagnostics.stderr       | 2 +-
 .../2229_closure_analysis/diagnostics/multilevel-path.stderr  | 2 +-
 .../2229_closure_analysis/diagnostics/repr_packed.stderr      | 2 +-
 .../diagnostics/simple-struct-min-capture.stderr              | 2 +-
 .../closures/2229_closure_analysis/diagnostics/union.stderr   | 2 +-
 tests/ui/closures/2229_closure_analysis/issue-90465.stderr    | 2 +-
 .../2229_closure_analysis/match/match-edge-cases_2.stderr     | 2 +-
 .../ui/closures/2229_closure_analysis/migrations/macro.stderr | 2 +-
 .../migrations/mir_calls_to_shims.stderr                      | 2 +-
 .../unique-borrows-are-invariant-1.stderr                     | 2 +-
 .../unique-borrows-are-invariant-2.stderr                     | 2 +-
 tests/ui/closures/add_semicolon_non_block_closure.stderr      | 2 +-
 tests/ui/closures/binder/const-bound.stderr                   | 2 +-
 tests/ui/closures/binder/disallow-const.stderr                | 2 +-
 tests/ui/closures/binder/disallow-ty.stderr                   | 2 +-
 tests/ui/closures/binder/implicit-return.stderr               | 2 +-
 tests/ui/closures/binder/type-bound-2.stderr                  | 2 +-
 tests/ui/closures/binder/type-bound.stderr                    | 2 +-
 tests/ui/closures/cannot-call-unsized-via-ptr.stderr          | 2 +-
 tests/ui/closures/capture-unsized-by-move.stderr              | 2 +-
 .../closure-bounds-cant-promote-superkind-in-struct.stderr    | 2 +-
 tests/ui/closures/closure-bounds-subtype.stderr               | 2 +-
 tests/ui/closures/closure-expected.stderr                     | 2 +-
 tests/ui/closures/closure-immutable-outer-variable.stderr     | 2 +-
 tests/ui/closures/closure-move-sync.stderr                    | 2 +-
 tests/ui/closures/closure-no-fn-1.stderr                      | 2 +-
 tests/ui/closures/closure-no-fn-2.stderr                      | 2 +-
 tests/ui/closures/closure-no-fn-3.stderr                      | 2 +-
 tests/ui/closures/closure-no-fn-4.stderr                      | 2 +-
 tests/ui/closures/closure-no-fn-5.stderr                      | 2 +-
 .../ui/closures/closure-referencing-itself-issue-25954.stderr | 2 +-
 tests/ui/closures/closure-reform-bad.stderr                   | 2 +-
 tests/ui/closures/closure-wrong-kind.stderr                   | 2 +-
 .../coerce-unsafe-closure-to-unsafe-fn-ptr.mir.stderr         | 2 +-
 .../coerce-unsafe-closure-to-unsafe-fn-ptr.thir.stderr        | 2 +-
 tests/ui/closures/coerce-unsafe-to-closure.stderr             | 2 +-
 tests/ui/closures/infer-signature-from-impl.next.stderr       | 2 +-
 tests/ui/closures/issue-10398.stderr                          | 2 +-
 tests/ui/closures/issue-112547.stderr                         | 2 +-
 tests/ui/closures/issue-113087.stderr                         | 2 +-
 tests/ui/closures/issue-11873.stderr                          | 2 +-
 tests/ui/closures/issue-25439.stderr                          | 2 +-
 tests/ui/closures/issue-67123.stderr                          | 2 +-
 tests/ui/closures/issue-6801.stderr                           | 2 +-
 .../ui/closures/issue-80313-mutable-borrow-in-closure.stderr  | 2 +-
 .../issue-80313-mutable-borrow-in-move-closure.stderr         | 2 +-
 tests/ui/closures/issue-80313-mutation-in-closure.stderr      | 2 +-
 tests/ui/closures/issue-80313-mutation-in-move-closure.stderr | 2 +-
 tests/ui/closures/issue-81700-mut-borrow.stderr               | 2 +-
 tests/ui/closures/issue-82438-mut-without-upvar.stderr        | 2 +-
 tests/ui/closures/issue-84044-drop-non-mut.stderr             | 2 +-
 tests/ui/closures/issue-84128.stderr                          | 2 +-
 tests/ui/closures/issue-99565.stderr                          | 2 +-
 tests/ui/closures/multiple-fn-bounds.stderr                   | 2 +-
 .../closures/old-closure-expression-remove-semicolon.stderr   | 2 +-
 tests/ui/closures/print/closure-print-generic-1.stderr        | 2 +-
 tests/ui/closures/print/closure-print-generic-2.stderr        | 2 +-
 .../print/closure-print-generic-trim-off-verbose-2.stderr     | 2 +-
 .../ui/closures/print/closure-print-generic-verbose-1.stderr  | 2 +-
 .../ui/closures/print/closure-print-generic-verbose-2.stderr  | 2 +-
 tests/ui/closures/print/closure-print-verbose.stderr          | 2 +-
 tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr  | 2 +-
 .../cmse-nonsecure/cmse-nonsecure-call/params-on-stack.stderr | 2 +-
 .../cmse-nonsecure-call/wrong-abi-location-1.stderr           | 2 +-
 .../cmse-nonsecure-call/wrong-abi-location-2.stderr           | 2 +-
 .../ui/cmse-nonsecure/cmse-nonsecure-entry/issue-83475.stderr | 2 +-
 .../cmse-nonsecure-entry/params-on-stack.stderr               | 2 +-
 .../cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.stderr | 2 +-
 tests/ui/cmse-nonsecure/cmse-nonsecure-entry/wrong-abi.stderr | 2 +-
 .../coherence-overlapping-inherent-impl-trait.stderr          | 2 +-
 tests/ui/codemap_tests/empty_span.stderr                      | 2 +-
 tests/ui/codemap_tests/huge_multispan_highlight.stderr        | 2 +-
 tests/ui/codemap_tests/issue-11715.stderr                     | 2 +-
 tests/ui/codemap_tests/issue-28308.stderr                     | 2 +-
 tests/ui/codemap_tests/one_line.stderr                        | 2 +-
 tests/ui/codemap_tests/tab_2.stderr                           | 2 +-
 tests/ui/codemap_tests/tab_3.stderr                           | 2 +-
 tests/ui/codemap_tests/two_files.stderr                       | 2 +-
 tests/ui/codemap_tests/unicode.normal.stderr                  | 2 +-
 tests/ui/coercion/coerce-block-tail-26978.stderr              | 2 +-
 tests/ui/coercion/coerce-block-tail-57749.stderr              | 2 +-
 tests/ui/coercion/coerce-block-tail-83783.stderr              | 2 +-
 tests/ui/coercion/coerce-block-tail-83850.stderr              | 2 +-
 tests/ui/coercion/coerce-block-tail.stderr                    | 2 +-
 tests/ui/coercion/coerce-mut.stderr                           | 2 +-
 tests/ui/coercion/coerce-reborrow-multi-arg-fail.stderr       | 2 +-
 tests/ui/coercion/coercion-slice.stderr                       | 2 +-
 tests/ui/coercion/issue-53475.stderr                          | 2 +-
 tests/ui/coercion/retslot-cast.stderr                         | 2 +-
 tests/ui/coherence/coherence-all-remote.stderr                | 2 +-
 tests/ui/coherence/coherence-bigint-param.stderr              | 2 +-
 ...oherence-blanket-conflicts-with-blanket-implemented.stderr | 2 +-
 ...erence-blanket-conflicts-with-blanket-unimplemented.stderr | 2 +-
 ...herence-blanket-conflicts-with-specific-cross-crate.stderr | 2 +-
 ...rence-blanket-conflicts-with-specific-multidispatch.stderr | 2 +-
 .../coherence-blanket-conflicts-with-specific-trait.stderr    | 2 +-
 .../coherence-blanket-conflicts-with-specific.stderr          | 2 +-
 tests/ui/coherence/coherence-cow.re_a.stderr                  | 2 +-
 tests/ui/coherence/coherence-cow.re_b.stderr                  | 2 +-
 tests/ui/coherence/coherence-cow.re_c.stderr                  | 2 +-
 tests/ui/coherence/coherence-cross-crate-conflict.stderr      | 2 +-
 tests/ui/coherence/coherence-error-suppression.stderr         | 2 +-
 .../coherence/coherence-fn-covariant-bound-vs-static.stderr   | 2 +-
 tests/ui/coherence/coherence-fn-implied-bounds.stderr         | 2 +-
 tests/ui/coherence/coherence-fn-inputs.stderr                 | 2 +-
 tests/ui/coherence/coherence-free-vs-bound-region.stderr      | 2 +-
 tests/ui/coherence/coherence-fundamental-trait-objects.stderr | 2 +-
 .../coherence/coherence-inherited-assoc-ty-cycle-err.stderr   | 2 +-
 tests/ui/coherence/coherence-inherited-subtyping.stderr       | 2 +-
 tests/ui/coherence/coherence-lone-type-parameter.stderr       | 2 +-
 tests/ui/coherence/coherence-negative-impls-safe.stderr       | 2 +-
 .../coherence-negative-outlives-lifetimes.stock.stderr        | 2 +-
 ...negative-outlives-lifetimes.with_negative_coherence.stderr | 2 +-
 .../ui/coherence/coherence-no-direct-lifetime-dispatch.stderr | 2 +-
 tests/ui/coherence/coherence-overlap-all-t-and-tuple.stderr   | 2 +-
 .../coherence-overlap-issue-23516-inherent.next.stderr        | 2 +-
 .../coherence-overlap-issue-23516-inherent.old.stderr         | 2 +-
 tests/ui/coherence/coherence-overlap-issue-23516.next.stderr  | 2 +-
 tests/ui/coherence/coherence-overlap-issue-23516.old.stderr   | 2 +-
 .../coherence-overlap-negate-not-use-feature-gate.stderr      | 2 +-
 tests/ui/coherence/coherence-overlap-trait-alias.stderr       | 2 +-
 tests/ui/coherence/coherence-overlap-upstream-inherent.stderr | 2 +-
 tests/ui/coherence/coherence-overlap-upstream.stderr          | 2 +-
 tests/ui/coherence/coherence-overlapping-pairs.stderr         | 2 +-
 tests/ui/coherence/coherence-pair-covered-uncovered-1.stderr  | 2 +-
 tests/ui/coherence/coherence-pair-covered-uncovered.stderr    | 2 +-
 .../ui/coherence/coherence-projection-conflict-orphan.stderr  | 2 +-
 .../coherence/coherence-projection-conflict-ty-param.stderr   | 2 +-
 tests/ui/coherence/coherence-projection-conflict.stderr       | 2 +-
 tests/ui/coherence/coherence-tuple-conflict.stderr            | 2 +-
 tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr  | 2 +-
 tests/ui/coherence/coherence-vec-local-2.stderr               | 2 +-
 tests/ui/coherence/coherence-vec-local.stderr                 | 2 +-
 tests/ui/coherence/coherence-wasm-bindgen.stderr              | 2 +-
 tests/ui/coherence/coherence-with-closure.stderr              | 2 +-
 tests/ui/coherence/coherence-with-coroutine.stock.stderr      | 2 +-
 .../coherence_copy_like_err_fundamental_struct_tuple.stderr   | 2 +-
 tests/ui/coherence/coherence_copy_like_err_struct.stderr      | 2 +-
 tests/ui/coherence/coherence_copy_like_err_tuple.stderr       | 2 +-
 tests/ui/coherence/coherence_inherent.stderr                  | 2 +-
 tests/ui/coherence/coherence_inherent_cc.stderr               | 2 +-
 tests/ui/coherence/coherence_local_err_struct.stderr          | 2 +-
 tests/ui/coherence/coherence_local_err_tuple.stderr           | 2 +-
 tests/ui/coherence/deep-bad-copy-reason.stderr                | 2 +-
 tests/ui/coherence/illegal-copy-bad-projection.stderr         | 2 +-
 tests/ui/coherence/impl-foreign-for-foreign.stderr            | 2 +-
 tests/ui/coherence/impl-foreign[foreign]-for-foreign.stderr   | 2 +-
 tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr  | 2 +-
 tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr      | 2 +-
 tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr        | 2 +-
 tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr      | 2 +-
 tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr            | 2 +-
 .../coherence/inter-crate-ambiguity-causes-notes.next.stderr  | 2 +-
 .../coherence/inter-crate-ambiguity-causes-notes.old.stderr   | 2 +-
 .../negative-coherence-check-placeholder-outlives.stderr      | 2 +-
 .../negative-coherence-considering-regions.any_lt.stderr      | 2 +-
 ...ceholder-region-constraints-on-unification.explicit.stderr | 2 +-
 .../strict-coherence-needs-negative-coherence.stderr          | 2 +-
 .../ui/coherence/warn-when-cycle-is-error-in-coherence.stderr | 2 +-
 tests/ui/command-line-diagnostics.stderr                      | 2 +-
 tests/ui/command/need-crate-arg-ignore-tidy.x.stderr          | 2 +-
 tests/ui/compare-method/proj-outlives-region.stderr           | 2 +-
 tests/ui/compare-method/region-extra-2.stderr                 | 2 +-
 tests/ui/compare-method/region-extra.stderr                   | 2 +-
 tests/ui/compare-method/region-unrelated.stderr               | 2 +-
 tests/ui/compare-method/reordered-type-param.stderr           | 2 +-
 tests/ui/compare-method/trait-bound-on-type-parameter.stderr  | 2 +-
 tests/ui/compare-method/traits-misc-mismatch-2.stderr         | 2 +-
 tests/ui/compile_error_macro.stderr                           | 2 +-
 tests/ui/conditional-compilation/cfg-attr-cfg-2.stderr        | 2 +-
 tests/ui/conditional-compilation/cfg-attr-crate-2.stderr      | 2 +-
 .../conditional-compilation/cfg-attr-invalid-predicate.stderr | 2 +-
 .../conditional-compilation/cfg-attr-multi-invalid-1.stderr   | 2 +-
 .../conditional-compilation/cfg-attr-multi-invalid-2.stderr   | 2 +-
 .../cfg-attr-unknown-attribute-macro-expansion.stderr         | 2 +-
 tests/ui/conditional-compilation/cfg-in-crate-1.stderr        | 2 +-
 tests/ui/conditional-compilation/cfg_accessible-stuck.stderr  | 2 +-
 .../ui/conditional-compilation/cfg_accessible-unstable.stderr | 2 +-
 tests/ui/conditional-compilation/test-cfg.stderr              | 2 +-
 tests/ui/confuse-field-and-method/issue-18343.stderr          | 2 +-
 tests/ui/confuse-field-and-method/issue-32128.stderr          | 2 +-
 tests/ui/confuse-field-and-method/private-field.stderr        | 2 +-
 tests/ui/conservative_impl_trait.stderr                       | 2 +-
 .../adt_const_params/const_param_ty_bad_empty_array.stderr    | 2 +-
 tests/ui/const-generics/associated-type-bound-fail.stderr     | 2 +-
 tests/ui/const-generics/bad-generic-in-copy-impl.stderr       | 2 +-
 tests/ui/const-generics/bad-subst-const-kind.stderr           | 2 +-
 tests/ui/const-generics/const-arg-type-arg-misordered.stderr  | 2 +-
 .../const-argument-non-static-lifetime.min.stderr             | 2 +-
 .../const-generics/const-generic-default-wont-borrowck.stderr | 2 +-
 .../ui/const-generics/const-param-before-other-params.stderr  | 2 +-
 .../const-param-type-depends-on-type-param-ungated.stderr     | 2 +-
 .../const-param-type-depends-on-type-param.full.stderr        | 2 +-
 .../const-param-type-depends-on-type-param.min.stderr         | 2 +-
 .../const-param-with-additional-obligations.stderr            | 2 +-
 tests/ui/const-generics/const-parameter-uppercase-lint.stderr | 2 +-
 tests/ui/const-generics/defaults/default-on-impl.stderr       | 2 +-
 .../defaults/default-param-wf-concrete.next.stderr            | 2 +-
 .../defaults/default-param-wf-concrete.old.stderr             | 2 +-
 tests/ui/const-generics/defaults/doesnt_infer.stderr          | 2 +-
 .../defaults/generic-expr-default-concrete.stderr             | 2 +-
 .../defaults/generic-expr-default-mismatched-types.stderr     | 2 +-
 .../defaults/param-order-err-pretty-prints-default.stderr     | 2 +-
 tests/ui/const-generics/defaults/self-referential.stderr      | 2 +-
 tests/ui/const-generics/different_generic_args.full.stderr    | 2 +-
 tests/ui/const-generics/different_generic_args.min.stderr     | 2 +-
 tests/ui/const-generics/different_generic_args_array.stderr   | 2 +-
 .../ui/const-generics/dont-evaluate-array-len-on-err-1.stderr | 2 +-
 .../ui/const-generics/early/const-expression-parameter.stderr | 2 +-
 .../ui/const-generics/early/const-param-from-outer-fn.stderr  | 2 +-
 tests/ui/const-generics/early/const-param-shadowing.stderr    | 2 +-
 tests/ui/const-generics/ensure_is_evaluatable.stderr          | 2 +-
 tests/ui/const-generics/exhaustive-value.stderr               | 2 +-
 tests/ui/const-generics/float-generic.adt_const_params.stderr | 2 +-
 tests/ui/const-generics/float-generic.simple.stderr           | 2 +-
 tests/ui/const-generics/fn-const-param-infer.full.stderr      | 2 +-
 tests/ui/const-generics/fn-const-param-infer.min.stderr       | 2 +-
 tests/ui/const-generics/fn_with_two_const_inputs.stderr       | 2 +-
 .../const-generics/forbid-non-structural_match-types.stderr   | 2 +-
 tests/ui/const-generics/generic-param-mismatch.stderr         | 2 +-
 tests/ui/const-generics/generic_arg_infer/issue-91614.stderr  | 2 +-
 .../generic_const_exprs/abstract-consts-as-cast-5.stderr      | 2 +-
 .../assoc_const_unification/doesnt_unify_evaluatable.stderr   | 2 +-
 tests/ui/const-generics/generic_const_exprs/closures.stderr   | 2 +-
 .../generic_const_exprs/const-block-is-poly.stderr            | 2 +-
 .../ui/const-generics/generic_const_exprs/eval-privacy.stderr | 2 +-
 .../feature-gate-generic_const_exprs.stderr                   | 2 +-
 .../const-generics/generic_const_exprs/from-sig-fail.stderr   | 2 +-
 .../ui/const-generics/generic_const_exprs/issue-105608.stderr | 2 +-
 .../issue-72819-generic-in-const-eval.min.stderr              | 2 +-
 .../ui/const-generics/generic_const_exprs/issue-76595.stderr  | 2 +-
 .../issue-79518-default_trait_method_normalization.stderr     | 2 +-
 .../ui/const-generics/generic_const_exprs/issue-80742.stderr  | 2 +-
 .../ui/const-generics/generic_const_exprs/issue-94287.stderr  | 2 +-
 .../generic_const_exprs/mismatched-gat-subst-kind.stderr      | 2 +-
 .../generic_const_exprs/needs_where_clause.stderr             | 2 +-
 .../const-generics/generic_const_exprs/no_where_clause.stderr | 2 +-
 .../non_local_anon_const_diagnostics.stderr                   | 2 +-
 .../generic_const_exprs/object-safety-err-ret.stderr          | 2 +-
 .../generic_const_exprs/object-safety-err-where-bounds.stderr | 2 +-
 .../generic_const_exprs/object-safety-ok-infer-err.stderr     | 2 +-
 .../generic_const_exprs/obligation-cause.stderr               | 2 +-
 .../const-generics/generic_const_exprs/type_mismatch.stderr   | 2 +-
 .../generic_const_exprs/typeid-equality-by-subtyping.stderr   | 2 +-
 .../generic_const_exprs/unresolved_lifetimes_error.stderr     | 2 +-
 tests/ui/const-generics/ice-68875.stderr                      | 2 +-
 .../ice-const-generic-function-return-ty.stderr               | 2 +-
 tests/ui/const-generics/infer/cannot-infer-const-args.stderr  | 2 +-
 tests/ui/const-generics/infer/issue-77092.stderr              | 2 +-
 tests/ui/const-generics/infer/method-chain.stderr             | 2 +-
 tests/ui/const-generics/infer/one-param-uninferred.stderr     | 2 +-
 tests/ui/const-generics/infer/uninferred-consts.stderr        | 2 +-
 tests/ui/const-generics/invalid-constant-in-args.stderr       | 2 +-
 tests/ui/const-generics/invariant.stderr                      | 2 +-
 tests/ui/const-generics/issue-112505-overflow.stderr          | 2 +-
 tests/ui/const-generics/issue-66451.stderr                    | 2 +-
 tests/ui/const-generics/issue-80471.stderr                    | 2 +-
 tests/ui/const-generics/issue-93647.stderr                    | 2 +-
 tests/ui/const-generics/issues/issue-56445-1.full.stderr      | 2 +-
 tests/ui/const-generics/issues/issue-56445-2.stderr           | 2 +-
 tests/ui/const-generics/issues/issue-56445-3.stderr           | 2 +-
 tests/ui/const-generics/issues/issue-61336-2.stderr           | 2 +-
 tests/ui/const-generics/issues/issue-61336.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-62878.full.stderr        | 2 +-
 .../const-generics/issues/issue-63322-forbid-dyn.full.stderr  | 2 +-
 .../const-generics/issues/issue-63322-forbid-dyn.min.stderr   | 2 +-
 tests/ui/const-generics/issues/issue-67375.full.stderr        | 2 +-
 tests/ui/const-generics/issues/issue-67739.full.stderr        | 2 +-
 tests/ui/const-generics/issues/issue-67739.min.stderr         | 2 +-
 tests/ui/const-generics/issues/issue-67945-1.full.stderr      | 2 +-
 tests/ui/const-generics/issues/issue-67945-2.full.stderr      | 2 +-
 tests/ui/const-generics/issues/issue-67945-2.min.stderr       | 2 +-
 tests/ui/const-generics/issues/issue-67945-3.full.stderr      | 2 +-
 tests/ui/const-generics/issues/issue-67945-4.full.stderr      | 2 +-
 tests/ui/const-generics/issues/issue-68615-adt.min.stderr     | 2 +-
 tests/ui/const-generics/issues/issue-68615-array.min.stderr   | 2 +-
 tests/ui/const-generics/issues/issue-71169.full.stderr        | 2 +-
 tests/ui/const-generics/issues/issue-71202.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-71382.full.stderr        | 2 +-
 tests/ui/const-generics/issues/issue-71382.min.stderr         | 2 +-
 tests/ui/const-generics/issues/issue-71611.full.stderr        | 2 +-
 tests/ui/const-generics/issues/issue-72352.full.stderr        | 2 +-
 tests/ui/const-generics/issues/issue-72352.min.stderr         | 2 +-
 tests/ui/const-generics/issues/issue-72845.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-73491.min.stderr         | 2 +-
 .../issue-73727-static-reference-array-const-param.min.stderr | 2 +-
 tests/ui/const-generics/issues/issue-74255.min.stderr         | 2 +-
 tests/ui/const-generics/issues/issue-75047.min.stderr         | 2 +-
 tests/ui/const-generics/issues/issue-79674.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-80062.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-80375.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-82956.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-83249.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-83466.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-83765.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-84659.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-86530.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-86820.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-90364.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-90455.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-97278.stderr             | 2 +-
 tests/ui/const-generics/issues/issue-98629.stderr             | 2 +-
 .../late-bound-vars/late-bound-in-return-issue-77357.stderr   | 2 +-
 .../late-bound-vars/late-bound-in-where-issue-83993.stderr    | 2 +-
 .../min_const_generics/const_default_first.stderr             | 2 +-
 .../min_const_generics/default_function_param.stderr          | 2 +-
 .../min_const_generics/forbid-self-no-normalize.stderr        | 2 +-
 .../min_const_generics/self-ty-in-const-2.stderr              | 2 +-
 tests/ui/const-generics/nested-type.full.stderr               | 2 +-
 tests/ui/const-generics/occurs-check/unify-n-nplusone.stderr  | 2 +-
 tests/ui/const-generics/occurs-check/unused-substs-1.stderr   | 2 +-
 tests/ui/const-generics/occurs-check/unused-substs-2.stderr   | 2 +-
 tests/ui/const-generics/occurs-check/unused-substs-3.stderr   | 2 +-
 tests/ui/const-generics/occurs-check/unused-substs-4.stderr   | 2 +-
 tests/ui/const-generics/occurs-check/unused-substs-5.stderr   | 2 +-
 .../outer-lifetime-in-const-generic-default.stderr            | 2 +-
 .../parent_generics_of_encoding_impl_trait.stderr             | 2 +-
 .../parser-error-recovery/issue-89013-no-assoc.stderr         | 2 +-
 .../parser-error-recovery/issue-89013-type.stderr             | 2 +-
 tests/ui/const-generics/projection-as-arg-const.stderr        | 2 +-
 tests/ui/const-generics/raw-ptr-const-param.full.stderr       | 2 +-
 tests/ui/const-generics/raw-ptr-const-param.min.stderr        | 2 +-
 .../ui/const-generics/struct-with-invalid-const-param.stderr  | 2 +-
 .../transmute-const-param-static-reference.min.stderr         | 2 +-
 tests/ui/const-generics/type-dependent/issue-71382.stderr     | 2 +-
 .../const-generics/type-dependent/type-mismatch.full.stderr   | 2 +-
 .../ui/const-generics/type-dependent/type-mismatch.min.stderr | 2 +-
 tests/ui/const-generics/unify_with_nested_expr.stderr         | 2 +-
 tests/ui/const-generics/unknown_adt.stderr                    | 2 +-
 tests/ui/const-generics/unused-type-param-suggestion.stderr   | 2 +-
 tests/ui/const-generics/wrong-normalization.stderr            | 2 +-
 tests/ui/const_prop/const-prop-ice.stderr                     | 2 +-
 tests/ui/const_prop/const-prop-ice2.stderr                    | 2 +-
 tests/ui/const_prop/const-prop-read-static-in-const.stderr    | 2 +-
 tests/ui/consts/array-literal-len-mismatch.stderr             | 2 +-
 tests/ui/consts/assoc_const_generic_impl.stderr               | 2 +-
 tests/ui/consts/async-block.with_feature.stderr               | 2 +-
 tests/ui/consts/const-array-oob.stderr                        | 2 +-
 tests/ui/consts/const-as-fn.stderr                            | 2 +-
 tests/ui/consts/const-block-const-bound.stderr                | 2 +-
 tests/ui/consts/const-blocks/fn-call-in-non-const.stderr      | 2 +-
 tests/ui/consts/const-blocks/trait-error.stderr               | 2 +-
 tests/ui/consts/const-call.stderr                             | 2 +-
 tests/ui/consts/const-cast-wrong-type.stderr                  | 2 +-
 tests/ui/consts/const-deref-ptr.stderr                        | 2 +-
 tests/ui/consts/const-err-multi.stderr                        | 2 +-
 tests/ui/consts/const-err4.64bit.stderr                       | 2 +-
 .../const-eval/assign-to-static-within-other-static.stderr    | 2 +-
 tests/ui/consts/const-eval/conditional_array_execution.stderr | 2 +-
 .../consts/const-eval/const-eval-intrinsic-promotion.stderr   | 2 +-
 tests/ui/consts/const-eval/const-eval-overflow-3.stderr       | 2 +-
 tests/ui/consts/const-eval/const-eval-overflow-4.stderr       | 2 +-
 tests/ui/consts/const-eval/const-eval-span.stderr             | 2 +-
 tests/ui/consts/const-eval/const_fn_target_feature.stderr     | 2 +-
 .../const-eval/const_panic-normalize-tabs-115498.stderr       | 2 +-
 tests/ui/consts/const-eval/const_panic_stability.e2021.stderr | 2 +-
 tests/ui/consts/const-eval/const_panic_track_caller.stderr    | 2 +-
 tests/ui/consts/const-eval/erroneous-const.stderr             | 2 +-
 tests/ui/consts/const-eval/erroneous-const2.stderr            | 2 +-
 tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr | 2 +-
 .../const-eval/heap/alloc_intrinsic_nontransient_fail.stderr  | 2 +-
 .../const-eval/heap/alloc_intrinsic_uninit.64bit.stderr       | 2 +-
 .../ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr  | 2 +-
 .../consts/const-eval/heap/dealloc_intrinsic_duplicate.stderr | 2 +-
 .../consts/const-eval/index-out-of-bounds-never-type.stderr   | 2 +-
 tests/ui/consts/const-eval/index_out_of_bounds.stderr         | 2 +-
 .../consts/const-eval/index_out_of_bounds_propagated.stderr   | 2 +-
 tests/ui/consts/const-eval/infinite_loop.stderr               | 2 +-
 tests/ui/consts/const-eval/issue-44578.stderr                 | 2 +-
 tests/ui/consts/const-eval/issue-49296.stderr                 | 2 +-
 tests/ui/consts/const-eval/issue-50814-2.mir-opt.stderr       | 2 +-
 tests/ui/consts/const-eval/issue-50814-2.normal.stderr        | 2 +-
 tests/ui/consts/const-eval/issue-50814.stderr                 | 2 +-
 tests/ui/consts/const-eval/issue-52475.stderr                 | 2 +-
 tests/ui/consts/const-eval/issue-70723.stderr                 | 2 +-
 tests/ui/consts/const-eval/issue-85155.stderr                 | 2 +-
 tests/ui/consts/const-eval/issue-85907.stderr                 | 2 +-
 tests/ui/consts/const-eval/livedrop.stderr                    | 2 +-
 tests/ui/consts/const-eval/match-test-ptr-null.stderr         | 2 +-
 tests/ui/consts/const-eval/mod-static-with-const-fn.stderr    | 2 +-
 tests/ui/consts/const-eval/nonnull_as_ref_ub.stderr           | 2 +-
 tests/ui/consts/const-eval/panic-assoc-never-type.stderr      | 2 +-
 tests/ui/consts/const-eval/panic-never-type.stderr            | 2 +-
 tests/ui/consts/const-eval/partial_ptr_overwrite.stderr       | 2 +-
 tests/ui/consts/const-eval/promoted_const_fn_fail.stderr      | 2 +-
 .../const-eval/promoted_const_fn_fail_deny_const_err.stderr   | 2 +-
 tests/ui/consts/const-eval/shift_overflow.stderr              | 2 +-
 tests/ui/consts/const-eval/size-of-t.stderr                   | 2 +-
 tests/ui/consts/const-eval/stable-metric/ctfe-fn-call.stderr  | 2 +-
 .../consts/const-eval/stable-metric/ctfe-labelled-loop.stderr | 2 +-
 .../ui/consts/const-eval/stable-metric/ctfe-recursion.stderr  | 2 +-
 tests/ui/consts/const-eval/transmute-const-promotion.stderr   | 2 +-
 tests/ui/consts/const-eval/transmute-const.64bit.stderr       | 2 +-
 tests/ui/consts/const-eval/ub-enum-overwrite.stderr           | 2 +-
 tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr      | 2 +-
 tests/ui/consts/const-eval/ub-upvars.64bit.stderr             | 2 +-
 tests/ui/consts/const-eval/union-const-eval-field.stderr      | 2 +-
 tests/ui/consts/const-eval/union_promotion.stderr             | 2 +-
 tests/ui/consts/const-eval/unused-broken-const-late.stderr    | 2 +-
 tests/ui/consts/const-eval/unused-broken-const.stderr         | 2 +-
 tests/ui/consts/const-eval/unwind-abort.stderr                | 2 +-
 ...sue-68062-const-extern-fns-dont-need-fn-specifier-2.stderr | 2 +-
 ...issue-68062-const-extern-fns-dont-need-fn-specifier.stderr | 2 +-
 tests/ui/consts/const-external-macro-const-err.stderr         | 2 +-
 tests/ui/consts/const-float-classify.stderr                   | 2 +-
 tests/ui/consts/const-fn-mismatch.stderr                      | 2 +-
 tests/ui/consts/const-for-feature-gate.stderr                 | 2 +-
 .../ui/consts/const-len-underflow-separate-spans.next.stderr  | 2 +-
 tests/ui/consts/const-len-underflow-separate-spans.old.stderr | 2 +-
 tests/ui/consts/const-len-underflow-subspans.stderr           | 2 +-
 tests/ui/consts/const-match-check.eval1.stderr                | 2 +-
 tests/ui/consts/const-match-check.eval2.stderr                | 2 +-
 .../consts/const-mut-refs/feature-gate-const_mut_refs.stderr  | 2 +-
 tests/ui/consts/const-points-to-static.64bit.stderr           | 2 +-
 tests/ui/consts/const-ptr-unique.stderr                       | 2 +-
 tests/ui/consts/const-size_of-cycle.stderr                    | 2 +-
 tests/ui/consts/const-slice-oob.stderr                        | 2 +-
 tests/ui/consts/const-suggest-feature.stderr                  | 2 +-
 tests/ui/consts/const-try-feature-gate.stderr                 | 2 +-
 tests/ui/consts/const-tup-index-span.stderr                   | 2 +-
 tests/ui/consts/const-unwrap.stderr                           | 2 +-
 .../ui/consts/const_fn_floating_point_arithmetic.gated.stderr | 2 +-
 tests/ui/consts/const_in_pattern/incomplete-slice.stderr      | 2 +-
 tests/ui/consts/const_in_pattern/issue-78057.stderr           | 2 +-
 tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr     | 2 +-
 tests/ui/consts/const_in_pattern/reject_non_partial_eq.stderr | 2 +-
 tests/ui/consts/const_let_refutable.stderr                    | 2 +-
 tests/ui/consts/const_unsafe_unreachable_ub.stderr            | 2 +-
 tests/ui/consts/control-flow/assert.stderr                    | 2 +-
 tests/ui/consts/control-flow/issue-46843.stderr               | 2 +-
 tests/ui/consts/control-flow/issue-50577.stderr               | 2 +-
 tests/ui/consts/control-flow/try.stderr                       | 2 +-
 tests/ui/consts/ct-var-in-collect_all_mismatches.stderr       | 2 +-
 tests/ui/consts/dangling-alloc-id-ice.stderr                  | 2 +-
 tests/ui/consts/dangling_raw_ptr.stderr                       | 2 +-
 tests/ui/consts/drop_box.stderr                               | 2 +-
 tests/ui/consts/drop_zst.stderr                               | 2 +-
 tests/ui/consts/escaping-bound-var.stderr                     | 2 +-
 tests/ui/consts/gate-do-not-const-check.stderr                | 2 +-
 tests/ui/consts/inline_asm.stderr                             | 2 +-
 tests/ui/consts/intrinsic_without_const_stab.stderr           | 2 +-
 tests/ui/consts/intrinsic_without_const_stab_fail.stderr      | 2 +-
 tests/ui/consts/invalid-const-in-body.stderr                  | 2 +-
 tests/ui/consts/invalid-inline-const-in-match-arm.stderr      | 2 +-
 tests/ui/consts/invalid-union.64bit.stderr                    | 2 +-
 tests/ui/consts/issue-104609.stderr                           | 2 +-
 tests/ui/consts/issue-104768.stderr                           | 2 +-
 tests/ui/consts/issue-17458.stderr                            | 2 +-
 tests/ui/consts/issue-17718-constants-not-static.stderr       | 2 +-
 tests/ui/consts/issue-18294.stderr                            | 2 +-
 tests/ui/consts/issue-25826.stderr                            | 2 +-
 tests/ui/consts/issue-28113.stderr                            | 2 +-
 tests/ui/consts/issue-32829.stderr                            | 2 +-
 tests/ui/consts/issue-3521.stderr                             | 2 +-
 tests/ui/consts/issue-36163.stderr                            | 2 +-
 tests/ui/consts/issue-44415.stderr                            | 2 +-
 tests/ui/consts/issue-52023-array-size-pointer-cast.stderr    | 2 +-
 tests/ui/consts/issue-52060.stderr                            | 2 +-
 tests/ui/consts/issue-63952.64bit.stderr                      | 2 +-
 tests/ui/consts/issue-64506.stderr                            | 2 +-
 tests/ui/consts/issue-68542-closure-in-array-len.stderr       | 2 +-
 tests/ui/consts/issue-70942-trait-vs-impl-mismatch.stderr     | 2 +-
 tests/ui/consts/issue-73976-monomorphic.stderr                | 2 +-
 tests/ui/consts/issue-76064.stderr                            | 2 +-
 tests/ui/consts/issue-79137-toogeneric.stderr                 | 2 +-
 tests/ui/consts/issue-79690.64bit.stderr                      | 2 +-
 tests/ui/consts/issue-87046.stderr                            | 2 +-
 tests/ui/consts/issue-90878-3.stderr                          | 2 +-
 tests/ui/consts/issue-90878.stderr                            | 2 +-
 tests/ui/consts/issue-miri-1910.stderr                        | 2 +-
 tests/ui/consts/match_ice.stderr                              | 2 +-
 tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr           | 2 +-
 tests/ui/consts/mir_check_nonconst.stderr                     | 2 +-
 tests/ui/consts/miri_unleashed/abi-mismatch.stderr            | 2 +-
 tests/ui/consts/miri_unleashed/assoc_const.stderr             | 2 +-
 tests/ui/consts/miri_unleashed/assoc_const_2.stderr           | 2 +-
 tests/ui/consts/miri_unleashed/box.stderr                     | 2 +-
 tests/ui/consts/miri_unleashed/drop.stderr                    | 2 +-
 .../feature-gate-unleash_the_miri_inside_of_you.stderr        | 2 +-
 tests/ui/consts/miri_unleashed/inline_asm.stderr              | 2 +-
 tests/ui/consts/miri_unleashed/mutable_references.stderr      | 2 +-
 tests/ui/consts/miri_unleashed/mutating_global.stderr         | 2 +-
 tests/ui/consts/miri_unleashed/non_const_fn.stderr            | 2 +-
 tests/ui/consts/miri_unleashed/raw_mutable_const.stderr       | 2 +-
 tests/ui/consts/missing-larger-array-impl.stderr              | 2 +-
 tests/ui/consts/missing_span_in_backtrace.stderr              | 2 +-
 tests/ui/consts/nested_erroneous_ctfe.stderr                  | 2 +-
 tests/ui/consts/partial_qualif.stderr                         | 2 +-
 tests/ui/consts/qualif_overwrite.stderr                       | 2 +-
 tests/ui/consts/qualif_overwrite_2.stderr                     | 2 +-
 tests/ui/consts/raw-ptr-const.stderr                          | 2 +-
 tests/ui/consts/recursive-zst-static.default.stderr           | 2 +-
 tests/ui/consts/recursive-zst-static.unleash.stderr           | 2 +-
 tests/ui/consts/recursive.stderr                              | 2 +-
 tests/ui/consts/stable-precise-live-drops-in-libcore.stderr   | 2 +-
 .../ui/consts/static_mut_containing_mut_ref2.mut_refs.stderr  | 2 +-
 tests/ui/consts/static_mut_containing_mut_ref2.stock.stderr   | 2 +-
 tests/ui/consts/static_mut_containing_mut_ref3.stderr         | 2 +-
 tests/ui/consts/timeout.stderr                                | 2 +-
 tests/ui/consts/transmute-size-mismatch-before-typeck.stderr  | 2 +-
 tests/ui/consts/try-operator.stderr                           | 2 +-
 tests/ui/consts/uninhabited-const-issue-61744.stderr          | 2 +-
 tests/ui/consts/unstable-const-fn-in-libcore.stderr           | 2 +-
 tests/ui/copy-a-resource.stderr                               | 2 +-
 tests/ui/coroutine/async-coroutine-issue-67158.stderr         | 2 +-
 tests/ui/coroutine/coroutine-region-requirements.stderr       | 2 +-
 tests/ui/coroutine/coroutine-with-nll.stderr                  | 2 +-
 tests/ui/coroutine/drop-yield-twice.stderr                    | 2 +-
 tests/ui/coroutine/dropck-resume.stderr                       | 2 +-
 tests/ui/coroutine/gen_block_is_no_future.stderr              | 2 +-
 tests/ui/coroutine/gen_block_move.stderr                      | 2 +-
 tests/ui/coroutine/gen_fn.e2024.stderr                        | 2 +-
 tests/ui/coroutine/gen_fn.none.stderr                         | 2 +-
 tests/ui/coroutine/issue-102645.stderr                        | 2 +-
 tests/ui/coroutine/issue-45729-unsafe-in-coroutine.mir.stderr | 2 +-
 .../ui/coroutine/issue-45729-unsafe-in-coroutine.thir.stderr  | 2 +-
 tests/ui/coroutine/issue-48048.stderr                         | 2 +-
 tests/ui/coroutine/issue-64620-yield-array-element.stderr     | 2 +-
 tests/ui/coroutine/issue-88653.stderr                         | 2 +-
 tests/ui/coroutine/issue-91477.stderr                         | 2 +-
 tests/ui/coroutine/layout-error.stderr                        | 2 +-
 tests/ui/coroutine/metadata-sufficient-for-layout.stderr      | 2 +-
 tests/ui/coroutine/pattern-borrow.stderr                      | 2 +-
 tests/ui/coroutine/print/coroutine-print-verbose-3.stderr     | 2 +-
 tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr      | 2 +-
 tests/ui/coroutine/resume-arg-late-bound.stderr               | 2 +-
 tests/ui/coroutine/retain-resume-ref.stderr                   | 2 +-
 tests/ui/coroutine/self_referential_gen_block.stderr          | 2 +-
 tests/ui/coroutine/static-not-unpin.current.stderr            | 2 +-
 tests/ui/coroutine/static-not-unpin.next.stderr               | 2 +-
 tests/ui/coroutine/too-many-parameters.stderr                 | 2 +-
 tests/ui/coroutine/type-mismatch-error.stderr                 | 2 +-
 tests/ui/coroutine/unresolved-ct-var.stderr                   | 2 +-
 tests/ui/coroutine/unsized-capture-across-yield.stderr        | 2 +-
 tests/ui/coroutine/unsized-local-across-yield.stderr          | 2 +-
 tests/ui/coroutine/yield-in-args.stderr                       | 2 +-
 tests/ui/coroutine/yield-in-const.stderr                      | 2 +-
 tests/ui/coroutine/yield-in-function.stderr                   | 2 +-
 tests/ui/coroutine/yield-in-static.stderr                     | 2 +-
 tests/ui/coroutine/yield-while-ref-reborrowed.stderr          | 2 +-
 tests/ui/crate-loading/crateresolve1.stderr                   | 2 +-
 tests/ui/crate-loading/crateresolve2.stderr                   | 2 +-
 tests/ui/crate-name-mismatch.stderr                           | 2 +-
 tests/ui/cross/cross-borrow-trait.stderr                      | 2 +-
 tests/ui/cross/cross-crate-macro-backtrace/main.stderr        | 2 +-
 tests/ui/cross/cross-file-errors/main.stderr                  | 2 +-
 tests/ui/cross/cross-fn-cache-hole.stderr                     | 2 +-
 tests/ui/custom-attribute-multisegment.stderr                 | 2 +-
 tests/ui/custom_test_frameworks/mismatch.stderr               | 2 +-
 tests/ui/cycle-trait/cycle-trait-default-type-trait.stderr    | 2 +-
 tests/ui/cycle-trait/cycle-trait-supertrait-direct.stderr     | 2 +-
 tests/ui/cycle-trait/cycle-trait-supertrait-indirect.stderr   | 2 +-
 tests/ui/cycle-trait/issue-12511.stderr                       | 2 +-
 .../debuginfo/debuginfo-type-name-layout-ice-94961-1.stderr   | 2 +-
 .../debuginfo/debuginfo-type-name-layout-ice-94961-2.stderr   | 2 +-
 tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr        | 2 +-
 tests/ui/dep-graph/dep-graph-variance-alias.stderr            | 2 +-
 tests/ui/deprecation/deprecated_no_stack_check.stderr         | 2 +-
 tests/ui/deprecation/deprecation-lint-2.stderr                | 2 +-
 tests/ui/deprecation/deprecation-lint-3.stderr                | 2 +-
 .../ui/deprecation/feature-gate-deprecated_suggestion.stderr  | 2 +-
 tests/ui/deprecation/invalid-literal.stderr                   | 2 +-
 .../issue-66340-deprecated-attr-non-meta-grammar.stderr       | 2 +-
 tests/ui/deref-non-pointer.stderr                             | 2 +-
 tests/ui/deref-patterns/gate.stderr                           | 2 +-
 tests/ui/derived-errors/issue-30580.stderr                    | 2 +-
 tests/ui/derived-errors/issue-31997-1.stderr                  | 2 +-
 tests/ui/derived-errors/issue-31997.stderr                    | 2 +-
 .../derives/clone-debug-dead-code-in-the-same-struct.stderr   | 2 +-
 tests/ui/derives/derive-assoc-type-not-impl.stderr            | 2 +-
 tests/ui/derives/derive-deadlock.stderr                       | 2 +-
 .../ui/derives/derives-span-Clone-enum-struct-variant.stderr  | 2 +-
 tests/ui/derives/derives-span-Clone-enum.stderr               | 2 +-
 tests/ui/derives/derives-span-Clone-struct.stderr             | 2 +-
 tests/ui/derives/derives-span-Clone-tuple-struct.stderr       | 2 +-
 .../ui/derives/derives-span-Debug-enum-struct-variant.stderr  | 2 +-
 tests/ui/derives/derives-span-Debug-enum.stderr               | 2 +-
 tests/ui/derives/derives-span-Debug-struct.stderr             | 2 +-
 tests/ui/derives/derives-span-Debug-tuple-struct.stderr       | 2 +-
 tests/ui/derives/derives-span-Default-struct.stderr           | 2 +-
 tests/ui/derives/derives-span-Default-tuple-struct.stderr     | 2 +-
 tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr   | 2 +-
 tests/ui/derives/derives-span-Eq-enum.stderr                  | 2 +-
 tests/ui/derives/derives-span-Eq-struct.stderr                | 2 +-
 tests/ui/derives/derives-span-Eq-tuple-struct.stderr          | 2 +-
 tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr | 2 +-
 tests/ui/derives/derives-span-Hash-enum.stderr                | 2 +-
 tests/ui/derives/derives-span-Hash-struct.stderr              | 2 +-
 tests/ui/derives/derives-span-Hash-tuple-struct.stderr        | 2 +-
 tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr  | 2 +-
 tests/ui/derives/derives-span-Ord-enum.stderr                 | 2 +-
 tests/ui/derives/derives-span-Ord-struct.stderr               | 2 +-
 tests/ui/derives/derives-span-Ord-tuple-struct.stderr         | 2 +-
 .../derives/derives-span-PartialEq-enum-struct-variant.stderr | 2 +-
 tests/ui/derives/derives-span-PartialEq-enum.stderr           | 2 +-
 tests/ui/derives/derives-span-PartialEq-struct.stderr         | 2 +-
 tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr   | 2 +-
 .../derives-span-PartialOrd-enum-struct-variant.stderr        | 2 +-
 tests/ui/derives/derives-span-PartialOrd-enum.stderr          | 2 +-
 tests/ui/derives/derives-span-PartialOrd-struct.stderr        | 2 +-
 tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr  | 2 +-
 tests/ui/derives/deriving-with-repr-packed-2.stderr           | 2 +-
 tests/ui/derives/deriving-with-repr-packed.stderr             | 2 +-
 tests/ui/derives/issue-97343.stderr                           | 2 +-
 tests/ui/deriving/issue-103157.stderr                         | 2 +-
 .../default-match-bindings-forbidden.stderr                   | 2 +-
 tests/ui/diagnostic-flags/terminal_urls.stderr                | 2 +-
 tests/ui/diagnostic-width/E0271.stderr                        | 2 +-
 tests/ui/diagnostic-width/flag-human.stderr                   | 2 +-
 tests/ui/diagnostic-width/flag-json.stderr                    | 2 +-
 .../non-1-width-unicode-multiline-label.stderr                | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming-2.stderr    | 2 +-
 .../diagnostic-width/non-whitespace-trimming-unicode.stderr   | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming.stderr      | 2 +-
 tests/ui/diagnostic-width/tab-column-numbers.stderr           | 2 +-
 tests/ui/diagnostic-width/tabs-trimming.stderr                | 2 +-
 tests/ui/diagnostic-width/whitespace-trimming-2.stderr        | 2 +-
 tests/ui/diagnostic-width/whitespace-trimming.stderr          | 2 +-
 .../feature-gate-diagnostic_on_unimplemented.stderr           | 2 +-
 ...re_unsupported_options_and_continue_to_use_fallback.stderr | 2 +-
 .../on_unimplemented/on_unimplemented_simple.stderr           | 2 +-
 .../report_warning_on_duplicated_options.stderr               | 2 +-
 tests/ui/diagnostic_namespace/requires_path.stderr            | 2 +-
 tests/ui/did_you_mean/issue-114112.stderr                     | 2 +-
 .../issue-21659-show-relevant-trait-impls-1.stderr            | 2 +-
 .../issue-21659-show-relevant-trait-impls-2.stderr            | 2 +-
 tests/ui/did_you_mean/issue-34337.stderr                      | 2 +-
 tests/ui/did_you_mean/issue-36798.stderr                      | 2 +-
 tests/ui/did_you_mean/issue-36798_unknown_field.stderr        | 2 +-
 tests/ui/did_you_mean/issue-37139.stderr                      | 2 +-
 tests/ui/did_you_mean/issue-38147-1.stderr                    | 2 +-
 tests/ui/did_you_mean/issue-38147-3.stderr                    | 2 +-
 tests/ui/did_you_mean/issue-38147-4.stderr                    | 2 +-
 tests/ui/did_you_mean/issue-40823.stderr                      | 2 +-
 .../did_you_mean/issue-46718-struct-pattern-dotdotdot.stderr  | 2 +-
 tests/ui/did_you_mean/println-typo.stderr                     | 2 +-
 tests/ui/did_you_mean/pub-macro-rules.stderr                  | 2 +-
 tests/ui/did_you_mean/recursion_limit.stderr                  | 2 +-
 tests/ui/did_you_mean/recursion_limit_macro.stderr            | 2 +-
 tests/ui/did_you_mean/replace-impl-infer-ty-from-trait.stderr | 2 +-
 tests/ui/directory_ownership/macro-expanded-mod.stderr        | 2 +-
 .../ui/directory_ownership/non-inline-mod-restriction.stderr  | 2 +-
 .../disallowed-deconstructing-destructing-struct-let.stderr   | 2 +-
 .../disallowed-deconstructing-destructing-struct-match.stderr | 2 +-
 tests/ui/diverging-fn-tail-35849.stderr                       | 2 +-
 tests/ui/does-nothing.stderr                                  | 2 +-
 tests/ui/dont-suggest-private-trait-method.stderr             | 2 +-
 tests/ui/double-type-import.stderr                            | 2 +-
 tests/ui/drop/drop-foreign-fundamental.stderr                 | 2 +-
 tests/ui/dropck/drop-with-active-borrows-1.stderr             | 2 +-
 tests/ui/dropck/drop-with-active-borrows-2.stderr             | 2 +-
 tests/ui/dropck/dropck-union.stderr                           | 2 +-
 tests/ui/dropck/dropck_no_diverge_on_nonregular_1.stderr      | 2 +-
 tests/ui/dropck/dropck_no_diverge_on_nonregular_2.stderr      | 2 +-
 tests/ui/dropck/explicit-implied-outlives.bad1.stderr         | 2 +-
 tests/ui/dropck/explicit-implied-outlives.bad2.stderr         | 2 +-
 tests/ui/dropck/issue-38868.stderr                            | 2 +-
 tests/ui/dropck/negative.stderr                               | 2 +-
 tests/ui/dropck/relate_lt_in_type_outlives_bound.stderr       | 2 +-
 tests/ui/dropck/reservation.stderr                            | 2 +-
 tests/ui/dropck/transitive-outlives.bad.stderr                | 2 +-
 tests/ui/dst/dst-bad-assign-2.stderr                          | 2 +-
 tests/ui/dst/dst-bad-deep-2.stderr                            | 2 +-
 tests/ui/dst/dst-bad-deep.stderr                              | 2 +-
 tests/ui/dst/issue-113447.stderr                              | 2 +-
 tests/ui/duplicate/dupe-symbols-1.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-2.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-3.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-4.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-5.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-6.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-7.stderr                      | 2 +-
 tests/ui/duplicate/dupe-symbols-8.stderr                      | 2 +-
 tests/ui/duplicate/duplicate-check-macro-exports.stderr       | 2 +-
 tests/ui/duplicate/duplicate-parameter.stderr                 | 2 +-
 tests/ui/duplicate_entry_error.stderr                         | 2 +-
 tests/ui/dyn-keyword/dyn-angle-brackets.stderr                | 2 +-
 tests/ui/dyn-star/align.normal.stderr                         | 2 +-
 tests/ui/dyn-star/align.over_aligned.stderr                   | 2 +-
 .../check-size-at-cast-polymorphic-bad.current.stderr         | 2 +-
 .../dyn-star/check-size-at-cast-polymorphic-bad.next.stderr   | 2 +-
 tests/ui/dyn-star/check-size-at-cast.stderr                   | 2 +-
 tests/ui/dyn-star/dyn-to-rigid.stderr                         | 2 +-
 tests/ui/dyn-star/error.stderr                                | 2 +-
 tests/ui/dyn-star/feature-gate-dyn_star.stderr                | 2 +-
 tests/ui/dyn-star/gated-span.stderr                           | 2 +-
 tests/ui/dyn-star/no-explicit-dyn-star.stderr                 | 2 +-
 tests/ui/dyn-star/no-implicit-dyn-star.stderr                 | 2 +-
 tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr           | 2 +-
 tests/ui/dyn-star/param-env-region-infer.current.stderr       | 2 +-
 tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr             | 2 +-
 tests/ui/dyn-star/upcast.stderr                               | 2 +-
 tests/ui/editions/dyn-trait-sugg-2021.stderr                  | 2 +-
 tests/ui/editions/edition-imports-2015.stderr                 | 2 +-
 tests/ui/editions/edition-imports-2018.stderr                 | 2 +-
 tests/ui/editions/edition-imports-virtual-2015-gated.stderr   | 2 +-
 tests/ui/editions/edition-keywords-2015-2018-expansion.stderr | 2 +-
 tests/ui/editions/edition-keywords-2018-2018-expansion.stderr | 2 +-
 tests/ui/editions/edition-raw-pointer-method-2015.stderr      | 2 +-
 tests/ui/editions/edition-raw-pointer-method-2018.stderr      | 2 +-
 tests/ui/elide-errors-on-mismatched-tuple.stderr              | 2 +-
 tests/ui/elided-test.stderr                                   | 2 +-
 tests/ui/empty/empty-comment.stderr                           | 2 +-
 tests/ui/empty/empty-linkname.stderr                          | 2 +-
 tests/ui/empty/empty-macro-use.stderr                         | 2 +-
 tests/ui/empty/empty-never-array.stderr                       | 2 +-
 tests/ui/entry-point/imported_main_conflict.stderr            | 2 +-
 .../imported_main_const_fn_item_type_forbidden.stderr         | 2 +-
 tests/ui/entry-point/imported_main_const_forbidden.stderr     | 2 +-
 .../imported_main_from_extern_crate_wrong_type.stderr         | 2 +-
 .../arbitrary_enum_discriminant-no-repr.stderr                | 2 +-
 .../enum-discriminant/forbidden-discriminant-kind-impl.stderr | 2 +-
 tests/ui/enum-discriminant/issue-41394.stderr                 | 2 +-
 .../issue-70453-generics-in-discr-ice-2.stderr                | 2 +-
 .../ui/enum-discriminant/issue-70453-polymorphic-ctfe.stderr  | 2 +-
 tests/ui/enum-discriminant/issue-72554.stderr                 | 2 +-
 tests/ui/enum/enum-and-module-in-same-scope.stderr            | 2 +-
 tests/ui/enum/enum-discrim-autosizing.stderr                  | 2 +-
 tests/ui/enum/enum-in-scope.stderr                            | 2 +-
 tests/ui/enum/enum-variant-type-2.stderr                      | 2 +-
 tests/ui/enum/suggest-default-attribute.stderr                | 2 +-
 tests/ui/error-codes/E0001.stderr                             | 2 +-
 tests/ui/error-codes/E0004-2.stderr                           | 2 +-
 tests/ui/error-codes/E0004.stderr                             | 2 +-
 tests/ui/error-codes/E0005.stderr                             | 2 +-
 tests/ui/error-codes/E0013.stderr                             | 2 +-
 tests/ui/error-codes/E0015.stderr                             | 2 +-
 tests/ui/error-codes/E0025.stderr                             | 2 +-
 tests/ui/error-codes/E0026-teach.stderr                       | 2 +-
 tests/ui/error-codes/E0026.stderr                             | 2 +-
 tests/ui/error-codes/E0029-teach.stderr                       | 2 +-
 tests/ui/error-codes/E0029.stderr                             | 2 +-
 tests/ui/error-codes/E0030-teach.stderr                       | 2 +-
 tests/ui/error-codes/E0030.stderr                             | 2 +-
 tests/ui/error-codes/E0033-teach.stderr                       | 2 +-
 tests/ui/error-codes/E0033.stderr                             | 2 +-
 tests/ui/error-codes/E0034.stderr                             | 2 +-
 tests/ui/error-codes/E0038.stderr                             | 2 +-
 tests/ui/error-codes/E0040.stderr                             | 2 +-
 tests/ui/error-codes/E0044.stderr                             | 2 +-
 tests/ui/error-codes/E0045.stderr                             | 2 +-
 tests/ui/error-codes/E0054.stderr                             | 2 +-
 tests/ui/error-codes/E0055.stderr                             | 2 +-
 tests/ui/error-codes/E0059.stderr                             | 2 +-
 tests/ui/error-codes/E0060.stderr                             | 2 +-
 tests/ui/error-codes/E0062.stderr                             | 2 +-
 tests/ui/error-codes/E0069.stderr                             | 2 +-
 tests/ui/error-codes/E0071.stderr                             | 2 +-
 tests/ui/error-codes/E0075.stderr                             | 2 +-
 tests/ui/error-codes/E0076.stderr                             | 2 +-
 tests/ui/error-codes/E0077.stderr                             | 2 +-
 tests/ui/error-codes/E0084.stderr                             | 2 +-
 tests/ui/error-codes/E0092.stderr                             | 2 +-
 tests/ui/error-codes/E0093.stderr                             | 2 +-
 tests/ui/error-codes/E0094.stderr                             | 2 +-
 tests/ui/error-codes/E0109.stderr                             | 2 +-
 tests/ui/error-codes/E0110.stderr                             | 2 +-
 tests/ui/error-codes/E0116.stderr                             | 2 +-
 tests/ui/error-codes/E0118.stderr                             | 2 +-
 tests/ui/error-codes/E0119.stderr                             | 2 +-
 tests/ui/error-codes/E0120.stderr                             | 2 +-
 tests/ui/error-codes/E0124.stderr                             | 2 +-
 tests/ui/error-codes/E0128.stderr                             | 2 +-
 tests/ui/error-codes/E0130.stderr                             | 2 +-
 tests/ui/error-codes/E0131.stderr                             | 2 +-
 tests/ui/error-codes/E0132.stderr                             | 2 +-
 tests/ui/error-codes/E0133.mir.stderr                         | 2 +-
 tests/ui/error-codes/E0133.thir.stderr                        | 2 +-
 tests/ui/error-codes/E0138.stderr                             | 2 +-
 tests/ui/error-codes/E0152.stderr                             | 2 +-
 tests/ui/error-codes/E0161.base.stderr                        | 2 +-
 tests/ui/error-codes/E0164.stderr                             | 2 +-
 tests/ui/error-codes/E0184.stderr                             | 2 +-
 tests/ui/error-codes/E0185.stderr                             | 2 +-
 tests/ui/error-codes/E0186.stderr                             | 2 +-
 tests/ui/error-codes/E0191.stderr                             | 2 +-
 tests/ui/error-codes/E0194.stderr                             | 2 +-
 tests/ui/error-codes/E0195.stderr                             | 2 +-
 tests/ui/error-codes/E0197.stderr                             | 2 +-
 tests/ui/error-codes/E0198.stderr                             | 2 +-
 tests/ui/error-codes/E0199.stderr                             | 2 +-
 tests/ui/error-codes/E0200.stderr                             | 2 +-
 tests/ui/error-codes/E0206.stderr                             | 2 +-
 tests/ui/error-codes/E0207.stderr                             | 2 +-
 tests/ui/error-codes/E0208.stderr                             | 2 +-
 tests/ui/error-codes/E0214.stderr                             | 2 +-
 tests/ui/error-codes/E0223.stderr                             | 2 +-
 tests/ui/error-codes/E0227.stderr                             | 2 +-
 tests/ui/error-codes/E0229.stderr                             | 2 +-
 tests/ui/error-codes/E0252.stderr                             | 2 +-
 tests/ui/error-codes/E0253.stderr                             | 2 +-
 tests/ui/error-codes/E0254.stderr                             | 2 +-
 tests/ui/error-codes/E0255.stderr                             | 2 +-
 tests/ui/error-codes/E0259.stderr                             | 2 +-
 tests/ui/error-codes/E0260.stderr                             | 2 +-
 tests/ui/error-codes/E0262.stderr                             | 2 +-
 tests/ui/error-codes/E0263.stderr                             | 2 +-
 tests/ui/error-codes/E0264.stderr                             | 2 +-
 tests/ui/error-codes/E0267.stderr                             | 2 +-
 tests/ui/error-codes/E0268.stderr                             | 2 +-
 tests/ui/error-codes/E0271.stderr                             | 2 +-
 tests/ui/error-codes/E0275.stderr                             | 2 +-
 tests/ui/error-codes/E0276.stderr                             | 2 +-
 tests/ui/error-codes/E0277-2.stderr                           | 2 +-
 tests/ui/error-codes/E0277-3.stderr                           | 2 +-
 tests/ui/error-codes/E0282.stderr                             | 2 +-
 tests/ui/error-codes/E0297.stderr                             | 2 +-
 tests/ui/error-codes/E0308-2.stderr                           | 2 +-
 tests/ui/error-codes/E0308-4.stderr                           | 2 +-
 tests/ui/error-codes/E0308.stderr                             | 2 +-
 tests/ui/error-codes/E0311.stderr                             | 2 +-
 tests/ui/error-codes/E0328.stderr                             | 2 +-
 tests/ui/error-codes/E0365.stderr                             | 2 +-
 tests/ui/error-codes/E0370.stderr                             | 2 +-
 tests/ui/error-codes/E0374.stderr                             | 2 +-
 tests/ui/error-codes/E0375.stderr                             | 2 +-
 tests/ui/error-codes/E0376.stderr                             | 2 +-
 tests/ui/error-codes/E0377.stderr                             | 2 +-
 tests/ui/error-codes/E0389.stderr                             | 2 +-
 tests/ui/error-codes/E0392.stderr                             | 2 +-
 tests/ui/error-codes/E0393.stderr                             | 2 +-
 tests/ui/error-codes/E0396-fixed.stderr                       | 2 +-
 tests/ui/error-codes/E0403.stderr                             | 2 +-
 tests/ui/error-codes/E0405.stderr                             | 2 +-
 tests/ui/error-codes/E0407.stderr                             | 2 +-
 tests/ui/error-codes/E0408.stderr                             | 2 +-
 tests/ui/error-codes/E0411.stderr                             | 2 +-
 tests/ui/error-codes/E0412.stderr                             | 2 +-
 tests/ui/error-codes/E0415.stderr                             | 2 +-
 tests/ui/error-codes/E0416.stderr                             | 2 +-
 tests/ui/error-codes/E0425.stderr                             | 2 +-
 tests/ui/error-codes/E0426.stderr                             | 2 +-
 tests/ui/error-codes/E0428.stderr                             | 2 +-
 tests/ui/error-codes/E0429.stderr                             | 2 +-
 tests/ui/error-codes/E0431.stderr                             | 2 +-
 tests/ui/error-codes/E0432.stderr                             | 2 +-
 tests/ui/error-codes/E0433.stderr                             | 2 +-
 tests/ui/error-codes/E0434.stderr                             | 2 +-
 tests/ui/error-codes/E0435.stderr                             | 2 +-
 tests/ui/error-codes/E0437.stderr                             | 2 +-
 tests/ui/error-codes/E0438.stderr                             | 2 +-
 tests/ui/error-codes/E0454.stderr                             | 2 +-
 tests/ui/error-codes/E0459.stderr                             | 2 +-
 tests/ui/error-codes/E0462.stderr                             | 2 +-
 tests/ui/error-codes/E0464.stderr                             | 2 +-
 tests/ui/error-codes/E0478.stderr                             | 2 +-
 tests/ui/error-codes/E0496.stderr                             | 2 +-
 tests/ui/error-codes/E0499.stderr                             | 2 +-
 tests/ui/error-codes/E0502.stderr                             | 2 +-
 tests/ui/error-codes/E0503.stderr                             | 2 +-
 tests/ui/error-codes/E0504.stderr                             | 2 +-
 tests/ui/error-codes/E0505.stderr                             | 2 +-
 tests/ui/error-codes/E0506.stderr                             | 2 +-
 tests/ui/error-codes/E0507.stderr                             | 2 +-
 tests/ui/error-codes/E0508-fail.stderr                        | 2 +-
 tests/ui/error-codes/E0508.stderr                             | 2 +-
 tests/ui/error-codes/E0509.stderr                             | 2 +-
 tests/ui/error-codes/E0511.stderr                             | 2 +-
 tests/ui/error-codes/E0512.stderr                             | 2 +-
 tests/ui/error-codes/E0516.stderr                             | 2 +-
 tests/ui/error-codes/E0519.stderr                             | 2 +-
 tests/ui/error-codes/E0520.stderr                             | 2 +-
 tests/ui/error-codes/E0522.stderr                             | 2 +-
 tests/ui/error-codes/E0523.stderr                             | 2 +-
 tests/ui/error-codes/E0527.stderr                             | 2 +-
 tests/ui/error-codes/E0528.stderr                             | 2 +-
 tests/ui/error-codes/E0529.stderr                             | 2 +-
 tests/ui/error-codes/E0530.stderr                             | 2 +-
 tests/ui/error-codes/E0532.stderr                             | 2 +-
 tests/ui/error-codes/E0534.stderr                             | 2 +-
 tests/ui/error-codes/E0559.stderr                             | 2 +-
 tests/ui/error-codes/E0560.stderr                             | 2 +-
 tests/ui/error-codes/E0565-1.stderr                           | 2 +-
 tests/ui/error-codes/E0565-2.stderr                           | 2 +-
 tests/ui/error-codes/E0565.stderr                             | 2 +-
 tests/ui/error-codes/E0572.stderr                             | 2 +-
 tests/ui/error-codes/E0583.stderr                             | 2 +-
 tests/ui/error-codes/E0585.stderr                             | 2 +-
 tests/ui/error-codes/E0586.stderr                             | 2 +-
 tests/ui/error-codes/E0594.stderr                             | 2 +-
 tests/ui/error-codes/E0596.stderr                             | 2 +-
 tests/ui/error-codes/E0597.stderr                             | 2 +-
 tests/ui/error-codes/E0599.stderr                             | 2 +-
 tests/ui/error-codes/E0600.stderr                             | 2 +-
 tests/ui/error-codes/E0601.stderr                             | 2 +-
 tests/ui/error-codes/E0603.stderr                             | 2 +-
 tests/ui/error-codes/E0604.stderr                             | 2 +-
 tests/ui/error-codes/E0607.stderr                             | 2 +-
 tests/ui/error-codes/E0608.stderr                             | 2 +-
 tests/ui/error-codes/E0609-private-method.stderr              | 2 +-
 tests/ui/error-codes/E0610.stderr                             | 2 +-
 tests/ui/error-codes/E0614.stderr                             | 2 +-
 tests/ui/error-codes/E0615.stderr                             | 2 +-
 tests/ui/error-codes/E0616.stderr                             | 2 +-
 tests/ui/error-codes/E0620.stderr                             | 2 +-
 .../ui/error-codes/E0621-does-not-trigger-for-closures.stderr | 2 +-
 tests/ui/error-codes/E0622.stderr                             | 2 +-
 tests/ui/error-codes/E0624.stderr                             | 2 +-
 tests/ui/error-codes/E0646.stderr                             | 2 +-
 tests/ui/error-codes/E0647.stderr                             | 2 +-
 tests/ui/error-codes/E0648.stderr                             | 2 +-
 tests/ui/error-codes/E0658.stderr                             | 2 +-
 tests/ui/error-codes/E0659.stderr                             | 2 +-
 tests/ui/error-codes/E0718.stderr                             | 2 +-
 tests/ui/error-codes/E0730.stderr                             | 2 +-
 tests/ui/error-codes/E0771.stderr                             | 2 +-
 tests/ui/error-codes/E0778.stderr                             | 2 +-
 tests/ui/error-codes/E0779.stderr                             | 2 +-
 tests/ui/error-codes/e0119/complex-impl.stderr                | 2 +-
 tests/ui/error-codes/e0119/issue-23563.stderr                 | 2 +-
 tests/ui/error-codes/e0119/issue-27403.stderr                 | 2 +-
 tests/ui/error-codes/e0119/issue-28981.stderr                 | 2 +-
 tests/ui/error-codes/e0119/so-37347311.stderr                 | 2 +-
 tests/ui/error-codes/ex-E0611.stderr                          | 2 +-
 tests/ui/error-codes/ex-E0612.stderr                          | 2 +-
 tests/ui/error-should-say-copy-not-pod.stderr                 | 2 +-
 tests/ui/errors/issue-104621-extern-not-file.stderr           | 2 +-
 tests/ui/errors/remap-path-prefix-reverse.local-self.stderr   | 2 +-
 .../ui/errors/remap-path-prefix-reverse.remapped-self.stderr  | 2 +-
 tests/ui/errors/remap-path-prefix.normal.stderr               | 2 +-
 .../ui/errors/remap-path-prefix.with-diagnostic-scope.stderr  | 2 +-
 .../errors/remap-path-prefix.without-diagnostic-scope.stderr  | 2 +-
 tests/ui/explicit-tail-calls/become-outside.array.stderr      | 2 +-
 tests/ui/explicit-tail-calls/become-outside.constant.stderr   | 2 +-
 tests/ui/explicit/explicit-call-to-dtor.stderr                | 2 +-
 tests/ui/explicit/explicit-call-to-supertrait-dtor.stderr     | 2 +-
 tests/ui/expr/if/attrs/bad-cfg.stderr                         | 2 +-
 tests/ui/expr/if/attrs/stmt-expr-gated.stderr                 | 2 +-
 tests/ui/expr/if/if-branch-types.stderr                       | 2 +-
 tests/ui/expr/if/if-let-arm-types.stderr                      | 2 +-
 tests/ui/expr/if/if-typeck.stderr                             | 2 +-
 tests/ui/expr/if/if-without-block.stderr                      | 2 +-
 tests/ui/expr/if/if-without-else-result.stderr                | 2 +-
 tests/ui/expr/if/issue-4201.stderr                            | 2 +-
 .../malformed_closure/block_instead_of_closure_in_arg.stderr  | 2 +-
 .../malformed_closure/missing_block_in_let_binding.stderr     | 2 +-
 tests/ui/expr/malformed_closure/ruby_style_closure.stderr     | 2 +-
 .../ruby_style_closure_successful_parse.stderr                | 2 +-
 tests/ui/ext-nonexistent.stderr                               | 2 +-
 tests/ui/extenv/extenv-arg-2-not-string-literal.stderr        | 2 +-
 tests/ui/extenv/extenv-escaped-var.stderr                     | 2 +-
 tests/ui/extenv/extenv-no-args.stderr                         | 2 +-
 tests/ui/extenv/extenv-not-defined-custom.stderr              | 2 +-
 tests/ui/extenv/extenv-not-defined-default.stderr             | 2 +-
 tests/ui/extenv/extenv-not-string-literal.stderr              | 2 +-
 tests/ui/extenv/extenv-too-many-args.stderr                   | 2 +-
 tests/ui/extern-flag/multiple-opts.stderr                     | 2 +-
 tests/ui/extern-flag/no-nounused.stderr                       | 2 +-
 tests/ui/extern-flag/noprelude.stderr                         | 2 +-
 tests/ui/extern-flag/public-and-private.stderr                | 2 +-
 tests/ui/extern/extern-const.stderr                           | 2 +-
 tests/ui/extern/extern-crate-rename.stderr                    | 2 +-
 tests/ui/extern/extern-ffi-fn-with-body.stderr                | 2 +-
 tests/ui/extern/extern-macro.stderr                           | 2 +-
 tests/ui/extern/extern-main-fn.stderr                         | 2 +-
 tests/ui/extern/extern-main-issue-86110.stderr                | 2 +-
 tests/ui/extern/extern-type-diag-not-similar.stderr           | 2 +-
 tests/ui/extern/extern-types-distinct-types.stderr            | 2 +-
 tests/ui/extern/extern-with-type-bounds.stderr                | 2 +-
 tests/ui/extern/extern-wrong-value-type.stderr                | 2 +-
 tests/ui/extern/issue-28324.mir.stderr                        | 2 +-
 tests/ui/extern/issue-28324.thir.stderr                       | 2 +-
 tests/ui/extern/issue-36122-accessing-externed-dst.stderr     | 2 +-
 tests/ui/extoption_env-no-args.stderr                         | 2 +-
 tests/ui/extoption_env-not-string-literal.stderr              | 2 +-
 tests/ui/extoption_env-too-many-args.stderr                   | 2 +-
 tests/ui/fail-simple.stderr                                   | 2 +-
 tests/ui/feature-gates/allow-features.stderr                  | 2 +-
 tests/ui/feature-gates/doc-rust-logo.stderr                   | 2 +-
 tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr     | 2 +-
 tests/ui/feature-gates/feature-gate-adt_const_params.stderr   | 2 +-
 .../ui/feature-gates/feature-gate-alloc-error-handler.stderr  | 2 +-
 .../ui/feature-gates/feature-gate-allocator_internals.stderr  | 2 +-
 .../feature-gate-allow-internal-unsafe-nested-macro.stderr    | 2 +-
 .../feature-gate-allow-internal-unstable-nested-macro.stderr  | 2 +-
 .../feature-gates/feature-gate-allow-internal-unstable.stderr | 2 +-
 .../feature-gates/feature-gate-asm_experimental_arch.stderr   | 2 +-
 tests/ui/feature-gates/feature-gate-asm_unwind.stderr         | 2 +-
 .../ui/feature-gates/feature-gate-assoc-type-defaults.stderr  | 2 +-
 .../feature-gate-associated_const_equality.stderr             | 2 +-
 tests/ui/feature-gates/feature-gate-box_patterns.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-builtin_syntax.stderr     | 2 +-
 tests/ui/feature-gates/feature-gate-c_variadic.stderr         | 2 +-
 .../ui/feature-gates/feature-gate-cfg-relocation-model.stderr | 2 +-
 .../feature-gates/feature-gate-cfg-target-thread-local.stderr | 2 +-
 .../ui/feature-gates/feature-gate-cfg_overflow_checks.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-cfg_sanitize.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-cfi_encoding.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-collapse_debuginfo.stderr | 2 +-
 tests/ui/feature-gates/feature-gate-compiler-builtins.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-concat_bytes.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-custom_mir.stderr         | 2 +-
 tests/ui/feature-gates/feature-gate-decl_macro.stderr         | 2 +-
 .../feature-gates/feature-gate-dispatch-from-dyn-cell.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-doc_cfg.stderr            | 2 +-
 tests/ui/feature-gates/feature-gate-doc_masked.stderr         | 2 +-
 tests/ui/feature-gates/feature-gate-doc_notable_trait.stderr  | 2 +-
 .../feature-gates/feature-gate-exclusive-range-pattern.stderr | 2 +-
 .../ui/feature-gates/feature-gate-exhaustive-patterns.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-extern_prelude.stderr     | 2 +-
 tests/ui/feature-gates/feature-gate-extern_types.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-feature-gate.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-ffi_const.stderr          | 2 +-
 tests/ui/feature-gates/feature-gate-ffi_pure.stderr           | 2 +-
 tests/ui/feature-gates/feature-gate-ffi_returns_twice.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-fn_align.stderr           | 2 +-
 tests/ui/feature-gates/feature-gate-fn_delegation.stderr      | 2 +-
 tests/ui/feature-gates/feature-gate-format_args_nl.stderr     | 2 +-
 tests/ui/feature-gates/feature-gate-fundamental.stderr        | 2 +-
 tests/ui/feature-gates/feature-gate-gen_blocks.none.stderr    | 2 +-
 .../feature-gate-generic_associated_types_extended.stderr     | 2 +-
 tests/ui/feature-gates/feature-gate-imported_main.stderr      | 2 +-
 .../feature-gate-inherent_associated_types.stderr             | 2 +-
 tests/ui/feature-gates/feature-gate-inline_const.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-inline_const_pat.stderr   | 2 +-
 tests/ui/feature-gates/feature-gate-large-assignments.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-link_cfg.stderr           | 2 +-
 .../ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr | 2 +-
 tests/ui/feature-gates/feature-gate-linkage.stderr            | 2 +-
 tests/ui/feature-gates/feature-gate-log_syntax.stderr         | 2 +-
 tests/ui/feature-gates/feature-gate-log_syntax2.stderr        | 2 +-
 tests/ui/feature-gates/feature-gate-marker_trait_attr.stderr  | 2 +-
 tests/ui/feature-gates/feature-gate-may-dangle.stderr         | 2 +-
 .../feature-gate-native_link_modifiers_as_needed.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-needs-allocator.stderr    | 2 +-
 tests/ui/feature-gates/feature-gate-negative_bounds.stderr    | 2 +-
 tests/ui/feature-gates/feature-gate-no_core.stderr            | 2 +-
 tests/ui/feature-gates/feature-gate-no_sanitize.stderr        | 2 +-
 .../feature-gate-non_exhaustive_omitted_patterns_lint.stderr  | 2 +-
 .../ui/feature-gates/feature-gate-non_lifetime_binders.stderr | 2 +-
 .../feature-gate-omit-gdb-pretty-printer-section.stderr       | 2 +-
 .../feature-gate-overlapping_marker_traits.stderr             | 2 +-
 tests/ui/feature-gates/feature-gate-prelude_import.stderr     | 2 +-
 .../feature-gate-proc_macro_byte_character.stderr             | 2 +-
 tests/ui/feature-gates/feature-gate-profiler-runtime.stderr   | 2 +-
 tests/ui/feature-gates/feature-gate-register_tool.stderr      | 2 +-
 tests/ui/feature-gates/feature-gate-repr128.stderr            | 2 +-
 .../feature-gate-rustc-allow-const-fn-unstable.stderr         | 2 +-
 .../ui/feature-gates/feature-gate-rustc_const_unstable.stderr | 2 +-
 tests/ui/feature-gates/feature-gate-simd.stderr               | 2 +-
 tests/ui/feature-gates/feature-gate-start.stderr              | 2 +-
 .../ui/feature-gates/feature-gate-stmt_expr_attributes.stderr | 2 +-
 tests/ui/feature-gates/feature-gate-thread_local.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-trace_macros.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-trait-alias.stderr        | 2 +-
 tests/ui/feature-gates/feature-gate-transparent_unions.stderr | 2 +-
 tests/ui/feature-gates/feature-gate-try_blocks.stderr         | 2 +-
 tests/ui/feature-gates/feature-gate-type_ascription.stderr    | 2 +-
 tests/ui/feature-gates/feature-gate-unix_sigpipe.stderr       | 2 +-
 .../ui/feature-gates/feature-gate-unsafe_pin_internals.stderr | 2 +-
 tests/ui/feature-gates/feature-gate-unsized_locals.stderr     | 2 +-
 .../feature-gates/feature-gate-unsized_tuple_coercion.stderr  | 2 +-
 .../feature-gates/feature-gate-with_negative_coherence.stderr | 2 +-
 .../feature-gates/feature-gated-feature-in-macro-arg.stderr   | 2 +-
 tests/ui/feature-gates/issue-49983-see-issue-0.stderr         | 2 +-
 tests/ui/feature-gates/rustc-private.stderr                   | 2 +-
 tests/ui/feature-gates/unknown-feature.stderr                 | 2 +-
 tests/ui/ffi_const2.stderr                                    | 2 +-
 tests/ui/fmt/closing-brace-as-fill.stderr                     | 2 +-
 .../ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr | 2 +-
 tests/ui/fmt/format-raw-string-error.stderr                   | 2 +-
 tests/ui/fmt/ifmt-unimpl.stderr                               | 2 +-
 tests/ui/fmt/ifmt-unknown-trait.stderr                        | 2 +-
 tests/ui/fmt/issue-104142.stderr                              | 2 +-
 tests/ui/fmt/issue-75307.stderr                               | 2 +-
 tests/ui/fmt/issue-86085.stderr                               | 2 +-
 tests/ui/fmt/issue-89173.stderr                               | 2 +-
 tests/ui/fmt/issue-91556.stderr                               | 2 +-
 tests/ui/fn-in-pat.stderr                                     | 2 +-
 tests/ui/fn/bad-main.stderr                                   | 2 +-
 tests/ui/fn/fn-bad-block-type.stderr                          | 2 +-
 tests/ui/fn/fn-closure-mutable-capture.stderr                 | 2 +-
 tests/ui/fn/implied-bounds-unnorm-associated-type-2.stderr    | 2 +-
 tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr    | 2 +-
 tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr    | 2 +-
 tests/ui/fn/implied-bounds-unnorm-associated-type.stderr      | 2 +-
 tests/ui/fn/issue-3044.stderr                                 | 2 +-
 tests/ui/fn/issue-3099.stderr                                 | 2 +-
 tests/ui/fn/issue-39259.stderr                                | 2 +-
 tests/ui/fn/signature-error-reporting-under-verbose.stderr    | 2 +-
 tests/ui/for/for-c-in-str.stderr                              | 2 +-
 tests/ui/for/for-else-err.stderr                              | 2 +-
 tests/ui/for/for-else-let-else-err.stderr                     | 2 +-
 tests/ui/for/for-expn.stderr                                  | 2 +-
 tests/ui/for/for-loop-bogosity.stderr                         | 2 +-
 tests/ui/for/for-loop-refutable-pattern-error-message.stderr  | 2 +-
 tests/ui/for/for-loop-type-error.stderr                       | 2 +-
 tests/ui/for/for-loop-unconstrained-element-type.stderr       | 2 +-
 tests/ui/for/issue-20605.current.stderr                       | 2 +-
 tests/ui/foreign-fn-return-lifetime.stderr                    | 2 +-
 .../foreign/issue-74120-lowering-of-ffi-block-bodies.stderr   | 2 +-
 tests/ui/foreign/issue-91370-foreign-fn-block-impl.stderr     | 2 +-
 .../ui/fully-qualified-type/fully-qualified-type-name1.stderr | 2 +-
 .../ui/fully-qualified-type/fully-qualified-type-name2.stderr | 2 +-
 .../ui/fully-qualified-type/fully-qualified-type-name4.stderr | 2 +-
 .../functional-struct-update-noncopyable.stderr               | 2 +-
 .../functional-struct-update-respects-privacy.stderr          | 2 +-
 tests/ui/future-incompatible-lint-group.stderr                | 2 +-
 .../assume-gat-normalization-for-nested-goals.stderr          | 2 +-
 tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr  | 2 +-
 tests/ui/generic-associated-types/bugs/hrtb-implied-2.stderr  | 2 +-
 tests/ui/generic-associated-types/bugs/hrtb-implied-3.stderr  | 2 +-
 tests/ui/generic-associated-types/bugs/issue-87735.stderr     | 2 +-
 tests/ui/generic-associated-types/bugs/issue-87755.stderr     | 2 +-
 tests/ui/generic-associated-types/bugs/issue-87803.stderr     | 2 +-
 tests/ui/generic-associated-types/bugs/issue-88382.stderr     | 2 +-
 tests/ui/generic-associated-types/bugs/issue-88460.stderr     | 2 +-
 tests/ui/generic-associated-types/bugs/issue-88526.stderr     | 2 +-
 tests/ui/generic-associated-types/bugs/issue-91762.stderr     | 2 +-
 .../collections-project-default.stderr                        | 2 +-
 .../generic-associated-types/collectivity-regression.stderr   | 2 +-
 .../const_params_have_right_type.stderr                       | 2 +-
 .../constraint-assoc-type-suggestion.stderr                   | 2 +-
 tests/ui/generic-associated-types/cross-crate-bounds.stderr   | 2 +-
 tests/ui/generic-associated-types/empty_generics.stderr       | 2 +-
 .../extended/lending_iterator.base.stderr                     | 2 +-
 .../extended/lending_iterator_2.base.stderr                   | 2 +-
 .../gat-bounds-not-checked-with-right-substitutions.stderr    | 2 +-
 .../ui/generic-associated-types/gat-in-trait-path.base.stderr | 2 +-
 tests/ui/generic-associated-types/issue-101020.stderr         | 2 +-
 tests/ui/generic-associated-types/issue-102114.current.stderr | 2 +-
 tests/ui/generic-associated-types/issue-102114.next.stderr    | 2 +-
 tests/ui/generic-associated-types/issue-102335-gat.stderr     | 2 +-
 .../generic-associated-types/issue-47206-where-clause.stderr  | 2 +-
 .../ui/generic-associated-types/issue-67510-pass.base.stderr  | 2 +-
 .../issue-68641-check-gat-bounds.stderr                       | 2 +-
 .../issue-68642-broken-llvm-ir.stderr                         | 2 +-
 .../ui/generic-associated-types/issue-68643-broken-mir.stderr | 2 +-
 .../issue-68644-codegen-selection.stderr                      | 2 +-
 .../issue-68645-codegen-fulfillment.stderr                    | 2 +-
 tests/ui/generic-associated-types/issue-68648-2.stderr        | 2 +-
 .../issue-68656-unsized-values.stderr                         | 2 +-
 tests/ui/generic-associated-types/issue-71176.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-74684-1.stderr        | 2 +-
 tests/ui/generic-associated-types/issue-74684-2.stderr        | 2 +-
 tests/ui/generic-associated-types/issue-76535.extended.stderr | 2 +-
 tests/ui/generic-associated-types/issue-78671.extended.stderr | 2 +-
 tests/ui/generic-associated-types/issue-79636-1.stderr        | 2 +-
 tests/ui/generic-associated-types/issue-79636-2.stderr        | 2 +-
 tests/ui/generic-associated-types/issue-80433.stderr          | 2 +-
 .../generic-associated-types/issue-81712-cyclic-traits.stderr | 2 +-
 tests/ui/generic-associated-types/issue-81862.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-87258_a.stderr        | 2 +-
 tests/ui/generic-associated-types/issue-87258_b.stderr        | 2 +-
 .../issue-87429-associated-type-default.stderr                | 2 +-
 .../issue-87429-specialization.stderr                         | 2 +-
 tests/ui/generic-associated-types/issue-88287.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-88360.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-88595.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-90014-tait.stderr     | 2 +-
 tests/ui/generic-associated-types/issue-90014-tait2.stderr    | 2 +-
 tests/ui/generic-associated-types/issue-90014.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-91883.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-92033.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-92096.stderr          | 2 +-
 tests/ui/generic-associated-types/issue-95305.stderr          | 2 +-
 .../method-unsatisfied-assoc-type-predicate.stderr            | 2 +-
 .../mismatched-where-clause-regions.stderr                    | 2 +-
 tests/ui/generic-associated-types/missing-item-sugg.stderr    | 2 +-
 .../missing-where-clause-on-trait.stderr                      | 2 +-
 .../ui/generic-associated-types/missing_lifetime_const.stderr | 2 +-
 .../multiple-type-params-with-unmet-bounds.stderr             | 2 +-
 tests/ui/generic-associated-types/own-bound-span.stderr       | 2 +-
 .../parse/trait-path-expected-token.stderr                    | 2 +-
 .../projection-bound-cycle-generic.stderr                     | 2 +-
 .../ui/generic-associated-types/projection-bound-cycle.stderr | 2 +-
 tests/ui/generic-associated-types/trait-objects.base.stderr   | 2 +-
 .../ui/generic-associated-types/trait-objects.extended.stderr | 2 +-
 tests/ui/generic-const-items/const-trait-impl.stderr          | 2 +-
 .../evaluatable-bounds.unconstrained.stderr                   | 2 +-
 tests/ui/generic-const-items/parameter-defaults.stderr        | 2 +-
 .../ui/generic-const-items/reference-outlives-referent.stderr | 2 +-
 .../generic-const-items/trivially-unsatisfied-bounds-0.stderr | 2 +-
 .../generic-const-items/trivially-unsatisfied-bounds-1.stderr | 2 +-
 .../generic-const-items/unsatisfied-evaluatable-bounds.stderr | 2 +-
 tests/ui/generics/generic-extern.stderr                       | 2 +-
 tests/ui/generics/generic-function-item-where-type.stderr     | 2 +-
 .../ui/generics/generic-impl-less-params-with-defaults.stderr | 2 +-
 .../ui/generics/generic-impl-more-params-with-defaults.stderr | 2 +-
 tests/ui/generics/generic-lifetime-trait-impl.stderr          | 2 +-
 .../ui/generics/generic-type-less-params-with-defaults.stderr | 2 +-
 .../ui/generics/generic-type-more-params-with-defaults.stderr | 2 +-
 tests/ui/generics/generic-type-params-forward-mention.stderr  | 2 +-
 tests/ui/generics/issue-59508-1.stderr                        | 2 +-
 tests/ui/generics/issue-59508.stderr                          | 2 +-
 ...1631-default-type-param-can-reference-self-in-trait.stderr | 2 +-
 tests/ui/generics/issue-79605.stderr                          | 2 +-
 .../issue-80512-param-reordering-with-defaults.stderr         | 2 +-
 tests/ui/generics/issue-83556.stderr                          | 2 +-
 tests/ui/generics/issue-95208-ignore-qself.stderr             | 2 +-
 tests/ui/generics/issue-95208.stderr                          | 2 +-
 tests/ui/generics/issue-98432.stderr                          | 2 +-
 tests/ui/generics/param-in-ct-in-ty-param-default.stderr      | 2 +-
 tests/ui/generics/single-colon-path-not-const-generics.stderr | 2 +-
 .../ui/generics/slightly-nice-generic-literal-messages.stderr | 2 +-
 .../exclusive_range_pattern_syntax_collision.stderr           | 2 +-
 .../feature-gate-half-open-range-patterns-in-slices.stderr    | 2 +-
 .../half-open-range-pats-inclusive-match-arrow.stderr         | 2 +-
 tests/ui/half-open-range-patterns/pat-tuple-5.stderr          | 2 +-
 .../slice_pattern_syntax_problem0.stderr                      | 2 +-
 tests/ui/hashmap/hashmap-index-mut.stderr                     | 2 +-
 tests/ui/hashmap/hashmap-iter-value-lifetime.stderr           | 2 +-
 tests/ui/hashmap/hashmap-lifetimes.stderr                     | 2 +-
 tests/ui/higher-ranked/higher-ranked-lifetime-error.stderr    | 2 +-
 .../hr-subtype.bound_a_b_ret_a_vs_bound_a_ret_a.stderr        | 2 +-
 .../higher-ranked/subtype/hr-subtype.bound_a_vs_free_x.stderr | 2 +-
 .../higher-ranked/subtype/hr-subtype.free_x_vs_free_y.stderr  | 2 +-
 .../ui/higher-ranked/subtype/placeholder-pattern-fail.stderr  | 2 +-
 .../ui/higher-ranked/trait-bounds/due-to-where-clause.stderr  | 2 +-
 tests/ui/higher-ranked/trait-bounds/fn-ptr.classic.stderr     | 2 +-
 .../trait-bounds/hang-on-deeply-nested-dyn.stderr             | 2 +-
 .../higher-ranked/trait-bounds/hrtb-cache-issue-54302.stderr  | 2 +-
 .../trait-bounds/hrtb-debruijn-in-receiver.stderr             | 2 +-
 .../higher-ranked/trait-bounds/hrtb-exists-forall-fn.stderr   | 2 +-
 .../hrtb-exists-forall-trait-contravariant.stderr             | 2 +-
 .../trait-bounds/hrtb-exists-forall-trait-invariant.stderr    | 2 +-
 .../hrtb-higher-ranker-supertraits-transitive.stderr          | 2 +-
 .../trait-bounds/hrtb-identity-fn-borrows.stderr              | 2 +-
 tests/ui/higher-ranked/trait-bounds/issue-46989.stderr        | 2 +-
 tests/ui/higher-ranked/trait-bounds/issue-58451.stderr        | 2 +-
 tests/ui/higher-ranked/trait-bounds/issue-95230.next.stderr   | 2 +-
 .../trait-bounds/normalize-under-binder/issue-62529-3.stderr  | 2 +-
 .../trait-bounds/normalize-under-binder/issue-90950.stderr    | 2 +-
 .../norm-before-method-resolution.stderr                      | 2 +-
 tests/ui/hygiene/arguments.stderr                             | 2 +-
 tests/ui/hygiene/cross-crate-glob-hygiene.stderr              | 2 +-
 tests/ui/hygiene/cross-crate-name-hiding-2.stderr             | 2 +-
 tests/ui/hygiene/cross-crate-name-hiding.stderr               | 2 +-
 tests/ui/hygiene/cross-crate-redefine.stderr                  | 2 +-
 tests/ui/hygiene/expansion-info-reset.stderr                  | 2 +-
 tests/ui/hygiene/fields-definition.stderr                     | 2 +-
 tests/ui/hygiene/fields-numeric-borrowck.stderr               | 2 +-
 tests/ui/hygiene/for-loop.stderr                              | 2 +-
 tests/ui/hygiene/hygienic-label-1.stderr                      | 2 +-
 tests/ui/hygiene/hygienic-label-2.stderr                      | 2 +-
 tests/ui/hygiene/hygienic-label-3.stderr                      | 2 +-
 tests/ui/hygiene/hygienic-label-4.stderr                      | 2 +-
 tests/ui/hygiene/impl_items-2.stderr                          | 2 +-
 tests/ui/hygiene/impl_items.stderr                            | 2 +-
 tests/ui/hygiene/intercrate.stderr                            | 2 +-
 tests/ui/hygiene/missing-self-diag.stderr                     | 2 +-
 tests/ui/hygiene/nested_macro_privacy.stderr                  | 2 +-
 tests/ui/hygiene/no_implicit_prelude-2018.stderr              | 2 +-
 tests/ui/hygiene/pattern-macro.stderr                         | 2 +-
 tests/ui/hygiene/privacy-early.stderr                         | 2 +-
 tests/ui/hygiene/privacy.stderr                               | 2 +-
 tests/ui/hygiene/trait_items.stderr                           | 2 +-
 tests/ui/illegal-sized-bound/mutability-mismatch-arg.stderr   | 2 +-
 tests/ui/illegal-ufcs-drop.stderr                             | 2 +-
 tests/ui/impl-header-lifetime-elision/dyn-trait.stderr        | 2 +-
 tests/ui/impl-header-lifetime-elision/path-elided.stderr      | 2 +-
 tests/ui/impl-header-lifetime-elision/trait-elided.stderr     | 2 +-
 .../alias-liveness/rpit-hidden-erased-unsoundness.stderr      | 2 +-
 .../alias-liveness/rpit-hide-lifetime-for-swap.stderr         | 2 +-
 .../alias-liveness/tait-hidden-erased-unsoundness.stderr      | 2 +-
 tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr   | 2 +-
 tests/ui/impl-trait/auto-trait-coherence.next.stderr          | 2 +-
 tests/ui/impl-trait/auto-trait-coherence.old.stderr           | 2 +-
 tests/ui/impl-trait/auto-trait-leak.stderr                    | 2 +-
 tests/ui/impl-trait/coherence-treats-tait-ambig.stderr        | 2 +-
 .../diagnostics/fully-qualified-path-impl-trait.stderr        | 2 +-
 tests/ui/impl-trait/does-not-live-long-enough.stderr          | 2 +-
 tests/ui/impl-trait/dont-suggest-box-on-empty-else-arm.stderr | 2 +-
 .../explicit-generic-args-for-impl.stderr                     | 2 +-
 .../not-enough-args.stderr                                    | 2 +-
 tests/ui/impl-trait/extra-item.stderr                         | 2 +-
 tests/ui/impl-trait/fallback_inference.stderr                 | 2 +-
 .../generic-with-implicit-hrtb-without-dyn.edition2015.stderr | 2 +-
 .../generic-with-implicit-hrtb-without-dyn.edition2021.stderr | 2 +-
 tests/ui/impl-trait/impl-fn-hrtb-bounds-2.stderr              | 2 +-
 tests/ui/impl-trait/impl-generic-mismatch-ab.stderr           | 2 +-
 tests/ui/impl-trait/impl-trait-in-macro.stderr                | 2 +-
 tests/ui/impl-trait/in-assoc-type.stderr                      | 2 +-
 tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr         | 2 +-
 .../impl-trait/in-trait/bad-item-bound-within-rpitit.stderr   | 2 +-
 .../in-trait/check-wf-on-non-defaulted-rpitit.stderr          | 2 +-
 tests/ui/impl-trait/in-trait/deep-match.stderr                | 2 +-
 tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr   | 2 +-
 tests/ui/impl-trait/in-trait/default-body-type-err.stderr     | 2 +-
 tests/ui/impl-trait/in-trait/doesnt-satisfy.stderr            | 2 +-
 .../in-trait/dont-project-to-rpitit-with-no-value.stderr      | 2 +-
 tests/ui/impl-trait/in-trait/foreign-dyn-error.stderr         | 2 +-
 tests/ui/impl-trait/in-trait/generics-mismatch.stderr         | 2 +-
 tests/ui/impl-trait/in-trait/issue-102571.stderr              | 2 +-
 .../ui/impl-trait/in-trait/method-signature-matches.lt.stderr | 2 +-
 .../in-trait/method-signature-matches.mismatch.stderr         | 2 +-
 .../in-trait/method-signature-matches.mismatch_async.stderr   | 2 +-
 .../in-trait/method-signature-matches.too_few.stderr          | 2 +-
 .../in-trait/method-signature-matches.too_many.stderr         | 2 +-
 .../in-trait/missing-lt-outlives-in-rpitit-114274.stderr      | 2 +-
 tests/ui/impl-trait/in-trait/opaque-in-impl-is-opaque.stderr  | 2 +-
 .../ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr  | 2 +-
 .../rpitit-hidden-types-self-implied-wf-via-param.stderr      | 2 +-
 .../in-trait/rpitit-hidden-types-self-implied-wf.stderr       | 2 +-
 .../impl-trait/in-trait/rpitit-shadowed-by-missing-adt.stderr | 2 +-
 .../ui/impl-trait/in-trait/sibling-function-constraint.stderr | 2 +-
 .../ui/impl-trait/in-trait/signature-mismatch.failure.stderr  | 2 +-
 tests/ui/impl-trait/in-trait/suggest-missing-item.stderr      | 2 +-
 .../impl-trait/in-trait/trait-more-generics-than-impl.stderr  | 2 +-
 tests/ui/impl-trait/in-trait/unconstrained-lt.stderr          | 2 +-
 tests/ui/impl-trait/issue-100075-2.stderr                     | 2 +-
 tests/ui/impl-trait/issue-100075.stderr                       | 2 +-
 tests/ui/impl-trait/issue-103181-1.current.stderr             | 2 +-
 tests/ui/impl-trait/issue-103181-1.next.stderr                | 2 +-
 tests/ui/impl-trait/issue-103181-2.stderr                     | 2 +-
 tests/ui/impl-trait/issue-35668.stderr                        | 2 +-
 tests/ui/impl-trait/issue-54966.stderr                        | 2 +-
 tests/ui/impl-trait/issue-55872-3.stderr                      | 2 +-
 tests/ui/impl-trait/issue-55872.stderr                        | 2 +-
 tests/ui/impl-trait/issue-86465.stderr                        | 2 +-
 tests/ui/impl-trait/issue-87450.stderr                        | 2 +-
 tests/ui/impl-trait/issue-99914.stderr                        | 2 +-
 .../issues/issue-21659-show-relevant-trait-impls-3.stderr     | 2 +-
 tests/ui/impl-trait/issues/issue-54600.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-54840.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-54895.stderr                 | 2 +-
 .../issue-57979-deeply-nested-impl-trait-in-assoc-proj.stderr | 2 +-
 .../impl-trait/issues/issue-57979-impl-trait-in-path.stderr   | 2 +-
 .../issues/issue-57979-nested-impl-trait-in-assoc-proj.stderr | 2 +-
 tests/ui/impl-trait/issues/issue-58504.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-67830.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-70877.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-70971.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-82139.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-83919.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-84073.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-84919.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-86642.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-87295.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-87340.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-88236.stderr                 | 2 +-
 tests/ui/impl-trait/issues/issue-92305.stderr                 | 2 +-
 .../impl-trait/issues/issue-99348-impl-compatibility.stderr   | 2 +-
 tests/ui/impl-trait/method-suggestion-no-duplication.stderr   | 2 +-
 tests/ui/impl-trait/multiple-defining-usages-in-body.stderr   | 2 +-
 .../ui/impl-trait/multiple-lifetimes/error-handling-2.stderr  | 2 +-
 tests/ui/impl-trait/multiple-lifetimes/error-handling.stderr  | 2 +-
 .../multiple-lifetimes/ordinary-bounds-unrelated.stderr       | 2 +-
 .../multiple-lifetimes/ordinary-bounds-unsuited.stderr        | 2 +-
 tests/ui/impl-trait/negative-reasoning.stderr                 | 2 +-
 tests/ui/impl-trait/nested-return-type4.stderr                | 2 +-
 tests/ui/impl-trait/nested-rpit-hrtb-2.stderr                 | 2 +-
 tests/ui/impl-trait/no-trait.stderr                           | 2 +-
 tests/ui/impl-trait/normalize-tait-in-const.stderr            | 2 +-
 tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr | 2 +-
 .../projection-mismatch-in-impl-where-clause.stderr           | 2 +-
 tests/ui/impl-trait/recursive-coroutine.current.stderr        | 2 +-
 tests/ui/impl-trait/recursive-coroutine.next.stderr           | 2 +-
 .../recursive-type-alias-impl-trait-declaration.stderr        | 2 +-
 tests/ui/impl-trait/region-escape-via-bound.stderr            | 2 +-
 tests/ui/impl-trait/rpit-not-sized.stderr                     | 2 +-
 tests/ui/impl-trait/suggest-calling-rpit-closure.stderr       | 2 +-
 .../ui/impl-trait/two_tait_defining_each_other.current.stderr | 2 +-
 tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr | 2 +-
 .../impl-trait/two_tait_defining_each_other3.current.stderr   | 2 +-
 .../ui/impl-trait/type-arg-mismatch-due-to-impl-trait.stderr  | 2 +-
 tests/ui/impl-trait/type_parameters_captured.stderr           | 2 +-
 tests/ui/impl-trait/unactionable_diagnostic.stderr            | 2 +-
 tests/ui/impl-trait/universal-mismatched-type.stderr          | 2 +-
 tests/ui/impl-trait/universal-two-impl-traits.stderr          | 2 +-
 tests/ui/impl-trait/universal_wrong_hrtb.stderr               | 2 +-
 tests/ui/impl-trait/where-allowed-2.stderr                    | 2 +-
 tests/ui/impl-unused-rps-in-assoc-type.stderr                 | 2 +-
 tests/ui/implicit-method-bind.stderr                          | 2 +-
 .../ui/implied-bounds/assoc-ty-wf-used-to-get-assoc-ty.stderr | 2 +-
 tests/ui/implied-bounds/impl-header-unnormalized-types.stderr | 2 +-
 .../impl-implied-bounds-compatibility-unnormalized.stderr     | 2 +-
 .../implied-bounds/impl-implied-bounds-compatibility.stderr   | 2 +-
 tests/ui/implied-bounds/issue-100690.stderr                   | 2 +-
 tests/ui/implied-bounds/issue-110161.stderr                   | 2 +-
 tests/ui/implied-bounds/normalization-nested.lifetime.stderr  | 2 +-
 tests/ui/implied-bounds/references-err.stderr                 | 2 +-
 tests/ui/imports/ambiguous-11.stderr                          | 2 +-
 tests/ui/imports/ambiguous-7.stderr                           | 2 +-
 tests/ui/imports/ambiguous-8.stderr                           | 2 +-
 tests/ui/imports/double-import.stderr                         | 2 +-
 tests/ui/imports/extern-crate-used.stderr                     | 2 +-
 tests/ui/imports/extern-with-ambiguous-1.stderr               | 2 +-
 tests/ui/imports/import-crate-var.stderr                      | 2 +-
 tests/ui/imports/import-from-missing.stderr                   | 2 +-
 tests/ui/imports/import-glob-0.stderr                         | 2 +-
 tests/ui/imports/import-glob-circular.stderr                  | 2 +-
 tests/ui/imports/import-loop-2.stderr                         | 2 +-
 tests/ui/imports/import-loop.stderr                           | 2 +-
 tests/ui/imports/import-prefix-macro-1.stderr                 | 2 +-
 tests/ui/imports/import-prefix-macro-2.stderr                 | 2 +-
 tests/ui/imports/import-trait-method.stderr                   | 2 +-
 tests/ui/imports/import2.stderr                               | 2 +-
 tests/ui/imports/import3.stderr                               | 2 +-
 tests/ui/imports/import4.stderr                               | 2 +-
 tests/ui/imports/issue-109148.stderr                          | 2 +-
 tests/ui/imports/issue-109343.stderr                          | 2 +-
 tests/ui/imports/issue-113953.stderr                          | 2 +-
 tests/ui/imports/issue-13404.stderr                           | 2 +-
 tests/ui/imports/issue-1697.stderr                            | 2 +-
 tests/ui/imports/issue-28388-1.stderr                         | 2 +-
 tests/ui/imports/issue-28388-2.stderr                         | 2 +-
 tests/ui/imports/issue-2937.stderr                            | 2 +-
 tests/ui/imports/issue-32354-suggest-import-rename.stderr     | 2 +-
 tests/ui/imports/issue-32833.stderr                           | 2 +-
 tests/ui/imports/issue-36881.stderr                           | 2 +-
 tests/ui/imports/issue-4366.stderr                            | 2 +-
 ...45799-bad-extern-crate-rename-suggestion-formatting.stderr | 2 +-
 tests/ui/imports/issue-45829/import-twice.stderr              | 2 +-
 tests/ui/imports/issue-45829/issue-45829.stderr               | 2 +-
 tests/ui/imports/issue-45829/rename-extern-vs-use.stderr      | 2 +-
 tests/ui/imports/issue-45829/rename-extern-with-tab.stderr    | 2 +-
 tests/ui/imports/issue-45829/rename-extern.stderr             | 2 +-
 tests/ui/imports/issue-45829/rename-use-vs-extern.stderr      | 2 +-
 tests/ui/imports/issue-45829/rename-use-with-tabs.stderr      | 2 +-
 tests/ui/imports/issue-45829/rename-with-path.stderr          | 2 +-
 tests/ui/imports/issue-45829/rename.stderr                    | 2 +-
 tests/ui/imports/issue-47623.stderr                           | 2 +-
 tests/ui/imports/issue-53512.stderr                           | 2 +-
 tests/ui/imports/issue-55884-1.stderr                         | 2 +-
 tests/ui/imports/issue-55884-2.stderr                         | 2 +-
 tests/ui/imports/issue-57015.stderr                           | 2 +-
 tests/ui/imports/issue-57539.stderr                           | 2 +-
 tests/ui/imports/issue-81413.stderr                           | 2 +-
 tests/ui/imports/issue-85992.stderr                           | 2 +-
 tests/ui/imports/issue-8640.stderr                            | 2 +-
 tests/ui/imports/issue-99695-b.stderr                         | 2 +-
 tests/ui/imports/issue-99695.stderr                           | 2 +-
 tests/ui/imports/no-std-inject.stderr                         | 2 +-
 tests/ui/imports/overlapping_pub_trait.stderr                 | 2 +-
 tests/ui/imports/resolve-other-libc.stderr                    | 2 +-
 tests/ui/imports/rfc-1560-warning-cycle.stderr                | 2 +-
 tests/ui/imports/unnamed_pub_trait.stderr                     | 2 +-
 tests/ui/imports/unused-import-issue-87973.stderr             | 2 +-
 tests/ui/imports/unused.stderr                                | 2 +-
 tests/ui/indexing/index-bot.stderr                            | 2 +-
 tests/ui/indexing/index-help.stderr                           | 2 +-
 tests/ui/indexing/index_message.stderr                        | 2 +-
 .../ui/indexing/point-at-index-for-obligation-failure.stderr  | 2 +-
 tests/ui/inference/ambiguous_type_parameter.stderr            | 2 +-
 tests/ui/inference/cannot-infer-async.stderr                  | 2 +-
 tests/ui/inference/cannot-infer-closure-circular.stderr       | 2 +-
 tests/ui/inference/cannot-infer-closure.stderr                | 2 +-
 tests/ui/inference/cannot-infer-partial-try-return.stderr     | 2 +-
 tests/ui/inference/inference_unstable_featured.stderr         | 2 +-
 tests/ui/inference/inference_unstable_forced.stderr           | 2 +-
 tests/ui/inference/issue-104649.stderr                        | 2 +-
 tests/ui/inference/issue-113354.stderr                        | 2 +-
 tests/ui/inference/issue-70082.stderr                         | 2 +-
 tests/ui/inference/issue-71309.stderr                         | 2 +-
 tests/ui/inference/issue-71584.stderr                         | 2 +-
 tests/ui/inference/issue-71732.stderr                         | 2 +-
 tests/ui/inference/issue-80816.stderr                         | 2 +-
 tests/ui/inference/issue-83606.stderr                         | 2 +-
 tests/ui/inference/issue-86162-1.stderr                       | 2 +-
 tests/ui/inference/issue-86162-2.stderr                       | 2 +-
 tests/ui/inference/multiple-impl-apply.stderr                 | 2 +-
 tests/ui/inference/need_type_info/concrete-impl.stderr        | 2 +-
 .../do-not-suggest-generic-arguments-for-turbofish.stderr     | 2 +-
 .../need_type_info/expr-struct-type-relative-enum.stderr      | 2 +-
 .../need_type_info/expr-struct-type-relative-gat.stderr       | 2 +-
 .../inference/need_type_info/expr-struct-type-relative.stderr | 2 +-
 .../inference/need_type_info/infer-var-for-self-param.stderr  | 2 +-
 tests/ui/inference/need_type_info/issue-103053.stderr         | 2 +-
 .../issue-107745-avoid-expr-from-macro-expansion.stderr       | 2 +-
 ...ssue-113264-incorrect-impl-trait-in-path-suggestion.stderr | 2 +-
 tests/ui/inference/need_type_info/self-ty-in-path.stderr      | 2 +-
 tests/ui/inference/need_type_info/type-alias-indirect.stderr  | 2 +-
 tests/ui/inference/question-mark-type-infer.stderr            | 2 +-
 tests/ui/infinite/infinite-alias.stderr                       | 2 +-
 tests/ui/infinite/infinite-instantiation.stderr               | 2 +-
 tests/ui/infinite/infinite-macro-expansion.stderr             | 2 +-
 tests/ui/infinite/infinite-recursion-const-fn.stderr          | 2 +-
 tests/ui/infinite/infinite-tag-type-recursion.stderr          | 2 +-
 tests/ui/infinite/infinite-trait-alias-recursion.stderr       | 2 +-
 .../infinite-type-alias-mutual-recursion.gated.stderr         | 2 +-
 tests/ui/infinite/infinite-vec-type-recursion.feature.stderr  | 2 +-
 tests/ui/infinite/infinite-vec-type-recursion.gated.stderr    | 2 +-
 tests/ui/inline-const/const-expr-generic-err2.stderr          | 2 +-
 tests/ui/inline-const/const-expr-lifetime-err.stderr          | 2 +-
 tests/ui/inline-const/expr-unsafe-err.mir.stderr              | 2 +-
 tests/ui/inline-const/expr-unsafe-err.thir.stderr             | 2 +-
 tests/ui/inline-const/expr-with-block-err.stderr              | 2 +-
 tests/ui/inline-const/pat-match-fndef.stderr                  | 2 +-
 tests/ui/inline-const/promotion.stderr                        | 2 +-
 tests/ui/inline-const/required-const.stderr                   | 2 +-
 tests/ui/inline-disallow-on-variant.stderr                    | 2 +-
 tests/ui/instrument-xray/target-not-supported.stderr          | 2 +-
 tests/ui/integral-variable-unification-error.stderr           | 2 +-
 tests/ui/interior-mutability/interior-mutability.stderr       | 2 +-
 tests/ui/internal-lints/existing_doc_keyword.stderr           | 2 +-
 tests/ui/internal/internal-unstable-const.stderr              | 2 +-
 tests/ui/internal/internal-unstable-thread-local.stderr       | 2 +-
 tests/ui/intrinsics/const-eval-select-stability.stderr        | 2 +-
 tests/ui/intrinsics/issue-28575.mir.stderr                    | 2 +-
 tests/ui/intrinsics/issue-28575.thir.stderr                   | 2 +-
 .../branch-protection-missing-pac-ret.BADTARGET.stderr        | 2 +-
 tests/ui/invalid-compile-flags/invalid-llvm-passes.stderr     | 2 +-
 .../invalid-module-declaration.stderr                         | 2 +-
 tests/ui/invalid-self-argument/bare-fn-start.stderr           | 2 +-
 tests/ui/invalid-self-argument/bare-fn.stderr                 | 2 +-
 tests/ui/invalid-self-argument/trait-fn.stderr                | 2 +-
 tests/ui/invalid/invalid-crate-type-macro.stderr              | 2 +-
 tests/ui/invalid/invalid-debugger-visualizer-target.stderr    | 2 +-
 tests/ui/invalid/invalid-macro-matcher.stderr                 | 2 +-
 tests/ui/invalid/invalid-no-sanitize.stderr                   | 2 +-
 tests/ui/invalid/invalid-path-in-const.stderr                 | 2 +-
 tests/ui/invalid_crate_type_syntax.stderr                     | 2 +-
 tests/ui/io-checks/non-ice-error-on-worker-io-fail.stderr     | 2 +-
 tests/ui/issues/issue-10291.stderr                            | 2 +-
 tests/ui/issues/issue-102964.stderr                           | 2 +-
 tests/ui/issues/issue-10465.stderr                            | 2 +-
 tests/ui/issues/issue-10545.stderr                            | 2 +-
 tests/ui/issues/issue-10656.stderr                            | 2 +-
 tests/ui/issues/issue-10764.stderr                            | 2 +-
 tests/ui/issues/issue-11192.stderr                            | 2 +-
 tests/ui/issues/issue-11374.stderr                            | 2 +-
 tests/ui/issues/issue-11593.stderr                            | 2 +-
 tests/ui/issues/issue-11681.stderr                            | 2 +-
 tests/ui/issues/issue-11692-1.stderr                          | 2 +-
 tests/ui/issues/issue-11692-2.stderr                          | 2 +-
 tests/ui/issues/issue-11844.stderr                            | 2 +-
 tests/ui/issues/issue-12028.stderr                            | 2 +-
 tests/ui/issues/issue-12041.stderr                            | 2 +-
 tests/ui/issues/issue-12127.stderr                            | 2 +-
 tests/ui/issues/issue-12187-1.stderr                          | 2 +-
 tests/ui/issues/issue-12187-2.stderr                          | 2 +-
 tests/ui/issues/issue-12863.stderr                            | 2 +-
 tests/ui/issues/issue-13058.stderr                            | 2 +-
 tests/ui/issues/issue-13446.stderr                            | 2 +-
 tests/ui/issues/issue-13482-2.stderr                          | 2 +-
 tests/ui/issues/issue-13482.stderr                            | 2 +-
 tests/ui/issues/issue-13497-2.stderr                          | 2 +-
 tests/ui/issues/issue-13497.stderr                            | 2 +-
 tests/ui/issues/issue-1362.stderr                             | 2 +-
 tests/ui/issues/issue-13847.stderr                            | 2 +-
 tests/ui/issues/issue-14091-2.stderr                          | 2 +-
 tests/ui/issues/issue-14091.stderr                            | 2 +-
 tests/ui/issues/issue-14092.stderr                            | 2 +-
 tests/ui/issues/issue-14285.stderr                            | 2 +-
 tests/ui/issues/issue-14366.stderr                            | 2 +-
 tests/ui/issues/issue-1448-2.stderr                           | 2 +-
 tests/ui/issues/issue-14541.stderr                            | 2 +-
 tests/ui/issues/issue-14721.stderr                            | 2 +-
 tests/ui/issues/issue-1476.stderr                             | 2 +-
 tests/ui/issues/issue-14853.stderr                            | 2 +-
 tests/ui/issues/issue-14915.stderr                            | 2 +-
 tests/ui/issues/issue-15034.stderr                            | 2 +-
 tests/ui/issues/issue-15094.stderr                            | 2 +-
 tests/ui/issues/issue-15207.stderr                            | 2 +-
 tests/ui/issues/issue-15381.stderr                            | 2 +-
 tests/ui/issues/issue-15756.stderr                            | 2 +-
 tests/ui/issues/issue-15783.stderr                            | 2 +-
 tests/ui/issues/issue-15896.stderr                            | 2 +-
 tests/ui/issues/issue-15965.stderr                            | 2 +-
 tests/ui/issues/issue-16149.stderr                            | 2 +-
 tests/ui/issues/issue-16250.stderr                            | 2 +-
 tests/ui/issues/issue-16338.stderr                            | 2 +-
 tests/ui/issues/issue-16401.stderr                            | 2 +-
 tests/ui/issues/issue-16562.stderr                            | 2 +-
 tests/ui/issues/issue-16683.stderr                            | 2 +-
 tests/ui/issues/issue-16725.stderr                            | 2 +-
 tests/ui/issues/issue-16939.stderr                            | 2 +-
 tests/ui/issues/issue-16966.stderr                            | 2 +-
 tests/ui/issues/issue-17001.stderr                            | 2 +-
 tests/ui/issues/issue-17033.stderr                            | 2 +-
 tests/ui/issues/issue-17252.stderr                            | 2 +-
 tests/ui/issues/issue-17337.stderr                            | 2 +-
 tests/ui/issues/issue-17373.stderr                            | 2 +-
 tests/ui/issues/issue-17405.stderr                            | 2 +-
 tests/ui/issues/issue-17551.stderr                            | 2 +-
 tests/ui/issues/issue-17651.stderr                            | 2 +-
 tests/ui/issues/issue-17758.stderr                            | 2 +-
 tests/ui/issues/issue-17800.stderr                            | 2 +-
 tests/ui/issues/issue-17904-2.stderr                          | 2 +-
 tests/ui/issues/issue-17933.stderr                            | 2 +-
 tests/ui/issues/issue-17954.stderr                            | 2 +-
 tests/ui/issues/issue-17959.stderr                            | 2 +-
 tests/ui/issues/issue-17994.stderr                            | 2 +-
 tests/ui/issues/issue-18058.stderr                            | 2 +-
 tests/ui/issues/issue-18107.stderr                            | 2 +-
 tests/ui/issues/issue-18159.stderr                            | 2 +-
 tests/ui/issues/issue-18183.stderr                            | 2 +-
 tests/ui/issues/issue-18423.stderr                            | 2 +-
 tests/ui/issues/issue-18446.stderr                            | 2 +-
 tests/ui/issues/issue-18532.stderr                            | 2 +-
 tests/ui/issues/issue-18566.stderr                            | 2 +-
 tests/ui/issues/issue-18611.stderr                            | 2 +-
 tests/ui/issues/issue-18819.stderr                            | 2 +-
 tests/ui/issues/issue-18919.stderr                            | 2 +-
 tests/ui/issues/issue-18959.stderr                            | 2 +-
 tests/ui/issues/issue-1900.stderr                             | 2 +-
 tests/ui/issues/issue-19086.stderr                            | 2 +-
 tests/ui/issues/issue-1920-1.stderr                           | 2 +-
 tests/ui/issues/issue-1920-2.stderr                           | 2 +-
 tests/ui/issues/issue-1920-3.stderr                           | 2 +-
 tests/ui/issues/issue-19244-1.stderr                          | 2 +-
 tests/ui/issues/issue-19244-2.stderr                          | 2 +-
 tests/ui/issues/issue-19482.stderr                            | 2 +-
 tests/ui/issues/issue-19521.stderr                            | 2 +-
 tests/ui/issues/issue-1962.stderr                             | 2 +-
 tests/ui/issues/issue-19692.stderr                            | 2 +-
 tests/ui/issues/issue-19734.stderr                            | 2 +-
 tests/ui/issues/issue-19922.stderr                            | 2 +-
 tests/ui/issues/issue-19991.stderr                            | 2 +-
 tests/ui/issues/issue-20162.stderr                            | 2 +-
 tests/ui/issues/issue-20261.stderr                            | 2 +-
 tests/ui/issues/issue-20313.stderr                            | 2 +-
 tests/ui/issues/issue-20433.stderr                            | 2 +-
 tests/ui/issues/issue-20714.stderr                            | 2 +-
 tests/ui/issues/issue-20772.stderr                            | 2 +-
 tests/ui/issues/issue-20831-debruijn.stderr                   | 2 +-
 tests/ui/issues/issue-20939.stderr                            | 2 +-
 tests/ui/issues/issue-21160.stderr                            | 2 +-
 tests/ui/issues/issue-21174.stderr                            | 2 +-
 tests/ui/issues/issue-21177.stderr                            | 2 +-
 tests/ui/issues/issue-21202.stderr                            | 2 +-
 tests/ui/issues/issue-21332.stderr                            | 2 +-
 tests/ui/issues/issue-21449.stderr                            | 2 +-
 tests/ui/issues/issue-2150.stderr                             | 2 +-
 tests/ui/issues/issue-2151.stderr                             | 2 +-
 tests/ui/issues/issue-21554.stderr                            | 2 +-
 tests/ui/issues/issue-21596.stderr                            | 2 +-
 tests/ui/issues/issue-21763.stderr                            | 2 +-
 tests/ui/issues/issue-21837.stderr                            | 2 +-
 tests/ui/issues/issue-21946.stderr                            | 2 +-
 tests/ui/issues/issue-21974.stderr                            | 2 +-
 tests/ui/issues/issue-22034.stderr                            | 2 +-
 tests/ui/issues/issue-22289.stderr                            | 2 +-
 tests/ui/issues/issue-22312.stderr                            | 2 +-
 tests/ui/issues/issue-22370.stderr                            | 2 +-
 tests/ui/issues/issue-22434.stderr                            | 2 +-
 tests/ui/issues/issue-22468.stderr                            | 2 +-
 tests/ui/issues/issue-22599.stderr                            | 2 +-
 tests/ui/issues/issue-22638.stderr                            | 2 +-
 tests/ui/issues/issue-22684.stderr                            | 2 +-
 tests/ui/issues/issue-22706.stderr                            | 2 +-
 tests/ui/issues/issue-2281-part1.stderr                       | 2 +-
 tests/ui/issues/issue-22872.stderr                            | 2 +-
 tests/ui/issues/issue-22874.stderr                            | 2 +-
 tests/ui/issues/issue-22886.stderr                            | 2 +-
 tests/ui/issues/issue-22933-2.stderr                          | 2 +-
 tests/ui/issues/issue-23041.stderr                            | 2 +-
 tests/ui/issues/issue-23046.stderr                            | 2 +-
 tests/ui/issues/issue-23073.stderr                            | 2 +-
 tests/ui/issues/issue-23122-1.stderr                          | 2 +-
 tests/ui/issues/issue-23122-2.stderr                          | 2 +-
 tests/ui/issues/issue-23189.stderr                            | 2 +-
 tests/ui/issues/issue-23217.stderr                            | 2 +-
 tests/ui/issues/issue-23253.stderr                            | 2 +-
 tests/ui/issues/issue-23281.stderr                            | 2 +-
 tests/ui/issues/issue-23302-1.stderr                          | 2 +-
 tests/ui/issues/issue-23302-2.stderr                          | 2 +-
 tests/ui/issues/issue-23302-3.stderr                          | 2 +-
 tests/ui/issues/issue-23543.stderr                            | 2 +-
 tests/ui/issues/issue-23544.stderr                            | 2 +-
 tests/ui/issues/issue-23966.stderr                            | 2 +-
 tests/ui/issues/issue-24013.stderr                            | 2 +-
 tests/ui/issues/issue-24322.stderr                            | 2 +-
 tests/ui/issues/issue-24352.stderr                            | 2 +-
 tests/ui/issues/issue-24357.stderr                            | 2 +-
 tests/ui/issues/issue-24424.stderr                            | 2 +-
 tests/ui/issues/issue-24819.stderr                            | 2 +-
 tests/ui/issues/issue-25076.stderr                            | 2 +-
 tests/ui/issues/issue-25368.stderr                            | 2 +-
 tests/ui/issues/issue-25386.stderr                            | 2 +-
 tests/ui/issues/issue-2590.stderr                             | 2 +-
 tests/ui/issues/issue-25901.stderr                            | 2 +-
 tests/ui/issues/issue-26056.stderr                            | 2 +-
 tests/ui/issues/issue-26217.stderr                            | 2 +-
 tests/ui/issues/issue-26237.stderr                            | 2 +-
 tests/ui/issues/issue-26619.stderr                            | 2 +-
 tests/ui/issues/issue-26812.stderr                            | 2 +-
 tests/ui/issues/issue-26905.stderr                            | 2 +-
 tests/ui/issues/issue-26948.stderr                            | 2 +-
 tests/ui/issues/issue-27008.stderr                            | 2 +-
 tests/ui/issues/issue-27078.stderr                            | 2 +-
 tests/ui/issues/issue-27340.stderr                            | 2 +-
 tests/ui/issues/issue-27433.stderr                            | 2 +-
 tests/ui/issues/issue-2823.stderr                             | 2 +-
 tests/ui/issues/issue-2848.stderr                             | 2 +-
 tests/ui/issues/issue-2849.stderr                             | 2 +-
 tests/ui/issues/issue-28568.stderr                            | 2 +-
 tests/ui/issues/issue-28586.stderr                            | 2 +-
 tests/ui/issues/issue-28625.stderr                            | 2 +-
 tests/ui/issues/issue-28776.mir.stderr                        | 2 +-
 tests/ui/issues/issue-28776.thir.stderr                       | 2 +-
 tests/ui/issues/issue-28971.stderr                            | 2 +-
 tests/ui/issues/issue-29147.stderr                            | 2 +-
 tests/ui/issues/issue-2951.stderr                             | 2 +-
 tests/ui/issues/issue-29861.stderr                            | 2 +-
 tests/ui/issues/issue-2995.stderr                             | 2 +-
 tests/ui/issues/issue-30007.stderr                            | 2 +-
 tests/ui/issues/issue-30123.stderr                            | 2 +-
 tests/ui/issues/issue-3021-b.stderr                           | 2 +-
 tests/ui/issues/issue-30236.stderr                            | 2 +-
 tests/ui/issues/issue-30589.stderr                            | 2 +-
 tests/ui/issues/issue-31011.stderr                            | 2 +-
 tests/ui/issues/issue-31511.stderr                            | 2 +-
 tests/ui/issues/issue-3154.stderr                             | 2 +-
 tests/ui/issues/issue-31910.stderr                            | 2 +-
 tests/ui/issues/issue-32122-1.stderr                          | 2 +-
 tests/ui/issues/issue-32122-2.stderr                          | 2 +-
 tests/ui/issues/issue-32326.stderr                            | 2 +-
 tests/ui/issues/issue-32377.stderr                            | 2 +-
 tests/ui/issues/issue-32782.stderr                            | 2 +-
 tests/ui/issues/issue-33293.stderr                            | 2 +-
 tests/ui/issues/issue-3344.stderr                             | 2 +-
 tests/ui/issues/issue-33504.stderr                            | 2 +-
 tests/ui/issues/issue-34047.stderr                            | 2 +-
 tests/ui/issues/issue-34209.stderr                            | 2 +-
 tests/ui/issues/issue-34229.stderr                            | 2 +-
 tests/ui/issues/issue-34349.stderr                            | 2 +-
 tests/ui/issues/issue-34373.stderr                            | 2 +-
 tests/ui/issues/issue-3477.stderr                             | 2 +-
 tests/ui/issues/issue-35139.stderr                            | 2 +-
 tests/ui/issues/issue-3521-2.stderr                           | 2 +-
 tests/ui/issues/issue-35241.stderr                            | 2 +-
 tests/ui/issues/issue-35570.stderr                            | 2 +-
 tests/ui/issues/issue-35976.unimported.stderr                 | 2 +-
 tests/ui/issues/issue-35988.stderr                            | 2 +-
 tests/ui/issues/issue-36400.stderr                            | 2 +-
 tests/ui/issues/issue-3668-2.stderr                           | 2 +-
 tests/ui/issues/issue-3668.stderr                             | 2 +-
 tests/ui/issues/issue-3680.stderr                             | 2 +-
 tests/ui/issues/issue-36836.stderr                            | 2 +-
 tests/ui/issues/issue-3702-2.stderr                           | 2 +-
 .../issues/issue-37311-type-length-limit/issue-37311.stderr   | 2 +-
 tests/ui/issues/issue-37665.stderr                            | 2 +-
 tests/ui/issues/issue-3779.stderr                             | 2 +-
 tests/ui/issues/issue-37884.stderr                            | 2 +-
 tests/ui/issues/issue-38412.stderr                            | 2 +-
 tests/ui/issues/issue-38458.stderr                            | 2 +-
 tests/ui/issues/issue-38919.stderr                            | 2 +-
 tests/ui/issues/issue-38954.stderr                            | 2 +-
 tests/ui/issues/issue-39175.stderr                            | 2 +-
 tests/ui/issues/issue-39211.stderr                            | 2 +-
 tests/ui/issues/issue-39687.stderr                            | 2 +-
 tests/ui/issues/issue-39848.stderr                            | 2 +-
 tests/ui/issues/issue-3993.stderr                             | 2 +-
 tests/ui/issues/issue-39970.stderr                            | 2 +-
 tests/ui/issues/issue-40288.stderr                            | 2 +-
 tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr    | 2 +-
 tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr    | 2 +-
 tests/ui/issues/issue-40510-1.stderr                          | 2 +-
 tests/ui/issues/issue-40510-3.stderr                          | 2 +-
 tests/ui/issues/issue-40610.stderr                            | 2 +-
 tests/ui/issues/issue-40749.stderr                            | 2 +-
 tests/ui/issues/issue-40861.stderr                            | 2 +-
 tests/ui/issues/issue-41139.stderr                            | 2 +-
 tests/ui/issues/issue-41229-ref-str.stderr                    | 2 +-
 tests/ui/issues/issue-41549.stderr                            | 2 +-
 tests/ui/issues/issue-41652/issue-41652.stderr                | 2 +-
 tests/ui/issues/issue-41726.stderr                            | 2 +-
 tests/ui/issues/issue-41742.stderr                            | 2 +-
 tests/ui/issues/issue-41880.stderr                            | 2 +-
 tests/ui/issues/issue-42106.stderr                            | 2 +-
 tests/ui/issues/issue-4265.stderr                             | 2 +-
 tests/ui/issues/issue-42755.stderr                            | 2 +-
 tests/ui/issues/issue-42796.stderr                            | 2 +-
 tests/ui/issues/issue-42880.stderr                            | 2 +-
 tests/ui/issues/issue-4335.stderr                             | 2 +-
 tests/ui/issues/issue-43355.stderr                            | 2 +-
 tests/ui/issues/issue-43420-no-over-suggest.stderr            | 2 +-
 tests/ui/issues/issue-43424.stderr                            | 2 +-
 tests/ui/issues/issue-43431.stderr                            | 2 +-
 tests/ui/issues/issue-43925.stderr                            | 2 +-
 tests/ui/issues/issue-43926.stderr                            | 2 +-
 tests/ui/issues/issue-44023.stderr                            | 2 +-
 tests/ui/issues/issue-44078.stderr                            | 2 +-
 tests/ui/issues/issue-44239.stderr                            | 2 +-
 tests/ui/issues/issue-44405.stderr                            | 2 +-
 tests/ui/issues/issue-4517.stderr                             | 2 +-
 tests/ui/issues/issue-45562.stderr                            | 2 +-
 tests/ui/issues/issue-45801.stderr                            | 2 +-
 tests/ui/issues/issue-45965.stderr                            | 2 +-
 tests/ui/issues/issue-46302.stderr                            | 2 +-
 tests/ui/issues/issue-46311.stderr                            | 2 +-
 tests/ui/issues/issue-46332.stderr                            | 2 +-
 tests/ui/issues/issue-46438.stderr                            | 2 +-
 tests/ui/issues/issue-46471-1.stderr                          | 2 +-
 tests/ui/issues/issue-46472.stderr                            | 2 +-
 tests/ui/issues/issue-46771.stderr                            | 2 +-
 tests/ui/issues/issue-46983.stderr                            | 2 +-
 tests/ui/issues/issue-47184.stderr                            | 2 +-
 tests/ui/issues/issue-4736.stderr                             | 2 +-
 tests/ui/issues/issue-47377.stderr                            | 2 +-
 tests/ui/issues/issue-47380.stderr                            | 2 +-
 tests/ui/issues/issue-47725.stderr                            | 2 +-
 tests/ui/issues/issue-48364.stderr                            | 2 +-
 tests/ui/issues/issue-48728.stderr                            | 2 +-
 tests/ui/issues/issue-48838.stderr                            | 2 +-
 tests/ui/issues/issue-4935.stderr                             | 2 +-
 tests/ui/issues/issue-4968.stderr                             | 2 +-
 tests/ui/issues/issue-4972.stderr                             | 2 +-
 tests/ui/issues/issue-49824.stderr                            | 2 +-
 tests/ui/issues/issue-49919.stderr                            | 2 +-
 .../issue-50264-inner-deref-trait/option-as_deref.stderr      | 2 +-
 .../issue-50264-inner-deref-trait/option-as_deref_mut.stderr  | 2 +-
 .../issue-50264-inner-deref-trait/result-as_deref.stderr      | 2 +-
 .../issue-50264-inner-deref-trait/result-as_deref_mut.stderr  | 2 +-
 tests/ui/issues/issue-50403.stderr                            | 2 +-
 tests/ui/issues/issue-50571.stderr                            | 2 +-
 tests/ui/issues/issue-50581.stderr                            | 2 +-
 tests/ui/issues/issue-50600.stderr                            | 2 +-
 tests/ui/issues/issue-50618.stderr                            | 2 +-
 tests/ui/issues/issue-5062.stderr                             | 2 +-
 tests/ui/issues/issue-50688.stderr                            | 2 +-
 tests/ui/issues/issue-50714-1.stderr                          | 2 +-
 tests/ui/issues/issue-50714.stderr                            | 2 +-
 tests/ui/issues/issue-50781.stderr                            | 2 +-
 tests/ui/issues/issue-50802.stderr                            | 2 +-
 tests/ui/issues/issue-51022.stderr                            | 2 +-
 tests/ui/issues/issue-51116.stderr                            | 2 +-
 tests/ui/issues/issue-51154.stderr                            | 2 +-
 tests/ui/issues/issue-5153.stderr                             | 2 +-
 .../issues/issue-51632-try-desugar-incompatible-types.stderr  | 2 +-
 tests/ui/issues/issue-51874.stderr                            | 2 +-
 tests/ui/issues/issue-52049.stderr                            | 2 +-
 tests/ui/issues/issue-52126-assign-op-invariance.stderr       | 2 +-
 tests/ui/issues/issue-52262.stderr                            | 2 +-
 tests/ui/issues/issue-5239-1.stderr                           | 2 +-
 tests/ui/issues/issue-52489.stderr                            | 2 +-
 tests/ui/issues/issue-52533.stderr                            | 2 +-
 tests/ui/issues/issue-52717.stderr                            | 2 +-
 tests/ui/issues/issue-53300.stderr                            | 2 +-
 tests/ui/issues/issue-53348.stderr                            | 2 +-
 tests/ui/issues/issue-53498.stderr                            | 2 +-
 tests/ui/issues/issue-5358-1.stderr                           | 2 +-
 tests/ui/issues/issue-54062.stderr                            | 2 +-
 tests/ui/issues/issue-5439.stderr                             | 2 +-
 tests/ui/issues/issue-54410.stderr                            | 2 +-
 tests/ui/issues/issue-55587.stderr                            | 2 +-
 tests/ui/issues/issue-55731.stderr                            | 2 +-
 tests/ui/issues/issue-56806.stderr                            | 2 +-
 tests/ui/issues/issue-56943.stderr                            | 2 +-
 tests/ui/issues/issue-57271.stderr                            | 2 +-
 tests/ui/issues/issue-57362-1.stderr                          | 2 +-
 tests/ui/issues/issue-57362-2.stderr                          | 2 +-
 tests/ui/issues/issue-57924.stderr                            | 2 +-
 tests/ui/issues/issue-5844.mir.stderr                         | 2 +-
 tests/ui/issues/issue-5844.thir.stderr                        | 2 +-
 tests/ui/issues/issue-58734.stderr                            | 2 +-
 tests/ui/issues/issue-5883.stderr                             | 2 +-
 tests/ui/issues/issue-58857.stderr                            | 2 +-
 tests/ui/issues/issue-59494.stderr                            | 2 +-
 tests/ui/issues/issue-5997-enum.stderr                        | 2 +-
 tests/ui/issues/issue-5997-struct.stderr                      | 2 +-
 tests/ui/issues/issue-60218.stderr                            | 2 +-
 tests/ui/issues/issue-61106.stderr                            | 2 +-
 tests/ui/issues/issue-61108.stderr                            | 2 +-
 tests/ui/issues/issue-61623.stderr                            | 2 +-
 tests/ui/issues/issue-62375.stderr                            | 2 +-
 tests/ui/issues/issue-64430.stderr                            | 2 +-
 tests/ui/issues/issue-64559.stderr                            | 2 +-
 tests/ui/issues/issue-64792-bad-unicode-ctor.stderr           | 2 +-
 tests/ui/issues/issue-65131.stderr                            | 2 +-
 tests/ui/issues/issue-65230.stderr                            | 2 +-
 .../issue-65634-raw-ident-suggestion.edition2015.stderr       | 2 +-
 .../issue-65634-raw-ident-suggestion.edition2018.stderr       | 2 +-
 tests/ui/issues/issue-6596-2.stderr                           | 2 +-
 tests/ui/issues/issue-67039-unsound-pin-partialeq.stderr      | 2 +-
 tests/ui/issues/issue-6738.stderr                             | 2 +-
 tests/ui/issues/issue-67552.stderr                            | 2 +-
 tests/ui/issues/issue-70381.stderr                            | 2 +-
 tests/ui/issues/issue-7044.stderr                             | 2 +-
 tests/ui/issues/issue-7061.stderr                             | 2 +-
 tests/ui/issues/issue-7092.stderr                             | 2 +-
 tests/ui/issues/issue-71406.stderr                            | 2 +-
 tests/ui/issues/issue-71676-2.stderr                          | 2 +-
 tests/ui/issues/issue-72076.stderr                            | 2 +-
 tests/ui/issues/issue-7246.stderr                             | 2 +-
 tests/ui/issues/issue-72839-error-overflow.stderr             | 2 +-
 tests/ui/issues/issue-73112.stderr                            | 2 +-
 tests/ui/issues/issue-7364.stderr                             | 2 +-
 tests/ui/issues/issue-74236/main.stderr                       | 2 +-
 tests/ui/issues/issue-75283.stderr                            | 2 +-
 tests/ui/issues/issue-7607-1.stderr                           | 2 +-
 tests/ui/issues/issue-76077.stderr                            | 2 +-
 tests/ui/issues/issue-77218/issue-77218-2.stderr              | 2 +-
 tests/ui/issues/issue-77218/issue-77218.stderr                | 2 +-
 tests/ui/issues/issue-78622.stderr                            | 2 +-
 tests/ui/issues/issue-7867.stderr                             | 2 +-
 tests/ui/issues/issue-7950.stderr                             | 2 +-
 tests/ui/issues/issue-7970a.stderr                            | 2 +-
 tests/ui/issues/issue-80607.stderr                            | 2 +-
 tests/ui/issues/issue-81584.stderr                            | 2 +-
 tests/ui/issues/issue-83048.stderr                            | 2 +-
 tests/ui/issues/issue-87199.stderr                            | 2 +-
 tests/ui/issues/issue-8727.stderr                             | 2 +-
 tests/ui/issues/issue-87490.stderr                            | 2 +-
 tests/ui/issues/issue-8767.stderr                             | 2 +-
 tests/ui/issues/issue-9575.stderr                             | 2 +-
 tests/ui/issues/issue-9814.stderr                             | 2 +-
 tests/ui/issues/issue-98299.stderr                            | 2 +-
 tests/ui/iterators/bound.stderr                               | 2 +-
 tests/ui/iterators/collect-into-array.stderr                  | 2 +-
 tests/ui/iterators/float_iterator_hint.stderr                 | 2 +-
 .../ui/iterators/invalid-iterator-chain-with-int-infer.stderr | 2 +-
 tests/ui/iterators/vec-on-unimplemented.stderr                | 2 +-
 tests/ui/json/json-short.stderr                               | 2 +-
 .../keyword/extern/keyword-extern-as-identifier-expr.stderr   | 2 +-
 .../ui/keyword/extern/keyword-extern-as-identifier-pat.stderr | 2 +-
 .../keyword/extern/keyword-extern-as-identifier-type.stderr   | 2 +-
 tests/ui/keyword/keyword-false-as-identifier.stderr           | 2 +-
 tests/ui/keyword/keyword-self-as-identifier.stderr            | 2 +-
 tests/ui/keyword/keyword-super-as-identifier.stderr           | 2 +-
 tests/ui/keyword/keyword-super.stderr                         | 2 +-
 tests/ui/keyword/keyword-true-as-identifier.stderr            | 2 +-
 tests/ui/kindck/kindck-impl-type-params-2.stderr              | 2 +-
 tests/ui/kindck/kindck-nonsendable-1.stderr                   | 2 +-
 tests/ui/kindck/kindck-send-owned.stderr                      | 2 +-
 tests/ui/lang-items/bad-add-impl.stderr                       | 2 +-
 tests/ui/lang-items/issue-19660.stderr                        | 2 +-
 tests/ui/lang-items/issue-86238.stderr                        | 2 +-
 tests/ui/lang-items/lang-item-missing.stderr                  | 2 +-
 tests/ui/lang-items/missing-clone-for-suggestion.stderr       | 2 +-
 tests/ui/lang-items/required-lang-item.stderr                 | 2 +-
 tests/ui/lang-items/start_lang_item_args.argc.stderr          | 2 +-
 tests/ui/lang-items/start_lang_item_args.argv.stderr          | 2 +-
 .../ui/lang-items/start_lang_item_args.argv_inner_ptr.stderr  | 2 +-
 tests/ui/lang-items/start_lang_item_args.main_args.stderr     | 2 +-
 tests/ui/lang-items/start_lang_item_args.main_ret.stderr      | 2 +-
 tests/ui/lang-items/start_lang_item_args.main_ty.stderr       | 2 +-
 .../lang-items/start_lang_item_args.missing_all_args.stderr   | 2 +-
 tests/ui/lang-items/start_lang_item_args.missing_ret.stderr   | 2 +-
 .../start_lang_item_args.missing_sigpipe_arg.stderr           | 2 +-
 tests/ui/lang-items/start_lang_item_args.sigpipe.stderr       | 2 +-
 tests/ui/lang-items/start_lang_item_args.start_ret.stderr     | 2 +-
 tests/ui/lang-items/start_lang_item_args.too_many_args.stderr | 2 +-
 .../ui/lang-items/start_lang_item_with_target_feature.stderr  | 2 +-
 tests/ui/late-bound-lifetimes/issue-80618.stderr              | 2 +-
 tests/ui/late-bound-lifetimes/mismatched_arg_count.stderr     | 2 +-
 tests/ui/layout/cannot-transmute-unnormalizable-type.stderr   | 2 +-
 tests/ui/layout/malformed-unsized-type-in-union.stderr        | 2 +-
 tests/ui/layout/too-big-with-padding.stderr                   | 2 +-
 tests/ui/layout/transmute-to-tail-with-err.stderr             | 2 +-
 tests/ui/lazy-type-alias-impl-trait/branches.stderr           | 2 +-
 .../extern-crate-has-lazy-type-aliases.locally_eager.stderr   | 2 +-
 .../extern-crate-has-lazy-type-aliases.locally_lazy.stderr    | 2 +-
 tests/ui/lazy-type-alias/leading-where-clause.stderr          | 2 +-
 tests/ui/lazy-type-alias/trailing-where-clause.stderr         | 2 +-
 .../lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr | 2 +-
 tests/ui/let-else/accidental-if.stderr                        | 2 +-
 tests/ui/let-else/issue-94176.stderr                          | 2 +-
 tests/ui/let-else/let-else-allow-unused.stderr                | 2 +-
 tests/ui/let-else/let-else-binding-explicit-mut-borrow.stderr | 2 +-
 tests/ui/let-else/let-else-binding-immutable.stderr           | 2 +-
 tests/ui/let-else/let-else-if.stderr                          | 2 +-
 tests/ui/let-else/let-else-no-double-error.stderr             | 2 +-
 tests/ui/let-else/let-else-scope.stderr                       | 2 +-
 tests/ui/let-else/let-else-slicing-error.stderr               | 2 +-
 tests/ui/let-else/let-else-then-diverge.stderr                | 2 +-
 tests/ui/lexer/lex-bad-char-literals-2.stderr                 | 2 +-
 tests/ui/lexer/lex-bad-char-literals-4.stderr                 | 2 +-
 tests/ui/lexer/lex-bad-token.stderr                           | 2 +-
 tests/ui/lexer/lex-stray-backslash.stderr                     | 2 +-
 tests/ui/lexer/unterminated-comment.stderr                    | 2 +-
 tests/ui/lexer/unterminated-nested-comment.stderr             | 2 +-
 tests/ui/lifetimes/borrowck-let-suggestion.stderr             | 2 +-
 tests/ui/lifetimes/conflicting-bounds.stderr                  | 2 +-
 tests/ui/lifetimes/copy_modulo_regions.stderr                 | 2 +-
 ...ing-lifetime-bound-on-trait-object-using-type-alias.stderr | 2 +-
 .../lifetimes/issue-107492-default-value-for-lifetime.stderr  | 2 +-
 tests/ui/lifetimes/issue-17728.stderr                         | 2 +-
 tests/ui/lifetimes/issue-34979.stderr                         | 2 +-
 ...issue-83753-invalid-associated-type-supertrait-hrtb.stderr | 2 +-
 tests/ui/lifetimes/issue-91763.stderr                         | 2 +-
 tests/ui/lifetimes/lifetime-elision-return-type-trait.stderr  | 2 +-
 .../lifetime-errors/42701_one_named_and_one_anonymous.stderr  | 2 +-
 .../ex1-return-one-existing-name-early-bound-in-struct.stderr | 2 +-
 .../ex1-return-one-existing-name-if-else-2.stderr             | 2 +-
 .../ex1-return-one-existing-name-if-else-3.stderr             | 2 +-
 .../ex1-return-one-existing-name-if-else-using-impl-2.stderr  | 2 +-
 .../ex1-return-one-existing-name-if-else-using-impl-3.stderr  | 2 +-
 .../ex1-return-one-existing-name-if-else-using-impl.stderr    | 2 +-
 .../ex1-return-one-existing-name-if-else.stderr               | 2 +-
 .../ex1-return-one-existing-name-return-type-is-anon.stderr   | 2 +-
 .../ex1-return-one-existing-name-self-is-anon.stderr          | 2 +-
 .../lifetime-errors/ex1b-return-no-names-if-else.stderr       | 2 +-
 .../lifetime-errors/ex2a-push-one-existing-name-2.stderr      | 2 +-
 .../ex2a-push-one-existing-name-early-bound.stderr            | 2 +-
 .../lifetime-errors/ex2a-push-one-existing-name.stderr        | 2 +-
 .../lifetime-errors/ex2b-push-no-existing-names.stderr        | 2 +-
 .../lifetime-errors/ex2c-push-inference-variable.stderr       | 2 +-
 .../lifetime-errors/ex2d-push-inference-variable-2.stderr     | 2 +-
 .../lifetime-errors/ex2e-push-inference-variable-3.stderr     | 2 +-
 .../lifetimes/lifetime-errors/ex3-both-anon-regions-2.stderr  | 2 +-
 .../ex3-both-anon-regions-both-are-structs-2.stderr           | 2 +-
 .../ex3-both-anon-regions-both-are-structs-3.stderr           | 2 +-
 ...th-anon-regions-both-are-structs-earlybound-regions.stderr | 2 +-
 ...oth-anon-regions-both-are-structs-latebound-regions.stderr | 2 +-
 .../ex3-both-anon-regions-both-are-structs.stderr             | 2 +-
 .../ex3-both-anon-regions-latebound-regions.stderr            | 2 +-
 .../ex3-both-anon-regions-one-is-struct-3.stderr              | 2 +-
 .../ex3-both-anon-regions-one-is-struct-4.stderr              | 2 +-
 .../ex3-both-anon-regions-one-is-struct.stderr                | 2 +-
 .../ex3-both-anon-regions-return-type-is-anon.stderr          | 2 +-
 .../lifetime-errors/ex3-both-anon-regions-self-is-anon.stderr | 2 +-
 .../ex3-both-anon-regions-using-impl-items.stderr             | 2 +-
 .../ui/lifetimes/lifetime-errors/ex3-both-anon-regions.stderr | 2 +-
 .../lifetimes/lifetime-mismatch-between-trait-and-impl.stderr | 2 +-
 tests/ui/lifetimes/nested-binder-print.stderr                 | 2 +-
 tests/ui/lifetimes/re-empty-in-error.stderr                   | 2 +-
 .../suggest-introducing-and-adding-missing-lifetime.stderr    | 2 +-
 ...unnamed-closure-doesnt-life-long-enough-issue-67634.stderr | 2 +-
 tests/ui/limits/huge-array-simple-64.stderr                   | 2 +-
 tests/ui/limits/huge-array.stderr                             | 2 +-
 tests/ui/limits/huge-enum.stderr                              | 2 +-
 tests/ui/limits/huge-struct.stderr                            | 2 +-
 tests/ui/limits/issue-15919-64.stderr                         | 2 +-
 tests/ui/limits/issue-17913.stderr                            | 2 +-
 tests/ui/limits/issue-55878.stderr                            | 2 +-
 tests/ui/limits/issue-69485-var-size-diffs-too-large.stderr   | 2 +-
 tests/ui/limits/issue-75158-64.stderr                         | 2 +-
 tests/ui/linkage-attr/incompatible-flavor.stderr              | 2 +-
 tests/ui/linkage-attr/issue-109144.stderr                     | 2 +-
 .../linkage-detect-extern-generated-name-collision.stderr     | 2 +-
 .../linkage-detect-local-generated-name-collision.stderr      | 2 +-
 tests/ui/linkage-attr/linkage2.stderr                         | 2 +-
 tests/ui/linkage-attr/linkage3.stderr                         | 2 +-
 tests/ui/linkage-attr/linkage4.stderr                         | 2 +-
 tests/ui/lint-group-forbid-always-trumps-cli.stderr           | 2 +-
 tests/ui/lint/bad-lint-cap2.stderr                            | 2 +-
 tests/ui/lint/bare-trait-objects-path.stderr                  | 2 +-
 tests/ui/lint/cli-lint-override.forbid_warn.stderr            | 2 +-
 tests/ui/lint/cli-lint-override.warn_deny.stderr              | 2 +-
 tests/ui/lint/command-line-lint-group-deny.stderr             | 2 +-
 tests/ui/lint/command-line-lint-group-forbid.stderr           | 2 +-
 tests/ui/lint/dead-code/basic.stderr                          | 2 +-
 tests/ui/lint/dead-code/closure-bang.stderr                   | 2 +-
 tests/ui/lint/dead-code/empty-unused-enum.stderr              | 2 +-
 tests/ui/lint/dead-code/impl-trait.stderr                     | 2 +-
 tests/ui/lint/dead-code/type-alias.stderr                     | 2 +-
 tests/ui/lint/dead-code/unused-assoc-fns.stderr               | 2 +-
 tests/ui/lint/dead-code/unused-struct-variant.stderr          | 2 +-
 tests/ui/lint/dead-code/unused-variant.stderr                 | 2 +-
 tests/ui/lint/dead-code/with-core-crate.stderr                | 2 +-
 tests/ui/lint/enable-unstable-lib-feature.stderr              | 2 +-
 tests/ui/lint/expr_attr_paren_order.stderr                    | 2 +-
 tests/ui/lint/forbid-group-group-1.stderr                     | 2 +-
 tests/ui/lint/issue-104897.stderr                             | 2 +-
 tests/ui/lint/issue-106991.stderr                             | 2 +-
 tests/ui/lint/issue-109152.stderr                             | 2 +-
 tests/ui/lint/issue-63364.stderr                              | 2 +-
 .../issue-70819-dont-override-forbid-in-same-scope.stderr     | 2 +-
 tests/ui/lint/issue-79744.stderr                              | 2 +-
 tests/ui/lint/issue-99387.stderr                              | 2 +-
 tests/ui/lint/let_underscore/let_underscore_lock.stderr       | 2 +-
 tests/ui/lint/lint-attr-non-item-node.stderr                  | 2 +-
 tests/ui/lint/lint-ctypes-73249-2.stderr                      | 2 +-
 tests/ui/lint/lint-ctypes-73249-3.stderr                      | 2 +-
 tests/ui/lint/lint-ctypes-73249-5.stderr                      | 2 +-
 tests/ui/lint/lint-ctypes-73251-1.stderr                      | 2 +-
 tests/ui/lint/lint-ctypes-73251-2.stderr                      | 2 +-
 tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr       | 2 +-
 tests/ui/lint/lint-forbid-internal-unsafe.stderr              | 2 +-
 tests/ui/lint/lint-match-arms.stderr                          | 2 +-
 tests/ui/lint/lint-missing-copy-implementations.stderr        | 2 +-
 tests/ui/lint/lint-non-snake-case-crate-2.stderr              | 2 +-
 tests/ui/lint/lint-non-snake-case-crate.stderr                | 2 +-
 tests/ui/lint/lint-non-snake-case-lifetimes.stderr            | 2 +-
 tests/ui/lint/lint-non-snake-case-modules.stderr              | 2 +-
 tests/ui/lint/lint-non-uppercase-associated-const.stderr      | 2 +-
 tests/ui/lint/lint-non-uppercase-trait-assoc-const.stderr     | 2 +-
 tests/ui/lint/lint-nonstandard-style-unicode-3.stderr         | 2 +-
 tests/ui/lint/lint-qualification.stderr                       | 2 +-
 tests/ui/lint/lint-removed-allow.stderr                       | 2 +-
 tests/ui/lint/lint-removed-cmdline.stderr                     | 2 +-
 tests/ui/lint/lint-removed.stderr                             | 2 +-
 tests/ui/lint/lint-renamed-allow.stderr                       | 2 +-
 tests/ui/lint/lint-renamed-cmdline.stderr                     | 2 +-
 tests/ui/lint/lint-renamed.stderr                             | 2 +-
 tests/ui/lint/lint-stability2.stderr                          | 2 +-
 tests/ui/lint/lint-stability3.stderr                          | 2 +-
 tests/ui/lint/lint-strict-provenance-fuzzy-casts.stderr       | 2 +-
 tests/ui/lint/lint-struct-necessary.stderr                    | 2 +-
 tests/ui/lint/lint-temporary-cstring-as-param.stderr          | 2 +-
 tests/ui/lint/lint-type-limits2.stderr                        | 2 +-
 tests/ui/lint/lint-type-limits3.stderr                        | 2 +-
 tests/ui/lint/lint-unconditional-drop-recursion.stderr        | 2 +-
 tests/ui/lint/lint-unnecessary-import-braces.stderr           | 2 +-
 tests/ui/lint/must_not_suspend/boxed.stderr                   | 2 +-
 tests/ui/lint/must_not_suspend/dedup.stderr                   | 2 +-
 .../must_not_suspend/feature-gate-must_not_suspend.stderr     | 2 +-
 tests/ui/lint/must_not_suspend/mutex.stderr                   | 2 +-
 tests/ui/lint/must_not_suspend/other_items.stderr             | 2 +-
 tests/ui/lint/must_not_suspend/ref.stderr                     | 2 +-
 tests/ui/lint/must_not_suspend/return.stderr                  | 2 +-
 tests/ui/lint/must_not_suspend/tuple-mismatch.stderr          | 2 +-
 tests/ui/lint/must_not_suspend/unit.stderr                    | 2 +-
 tests/ui/lint/opaque-ty-ffi-normalization-cycle.stderr        | 2 +-
 tests/ui/lint/opaque-ty-ffi-unsafe.stderr                     | 2 +-
 tests/ui/lint/renamed-lints-still-apply.stderr                | 2 +-
 .../rfc-2383-lint-reason/expect_missing_feature_gate.stderr   | 2 +-
 .../rfc-2383-lint-reason/expect_nested_lint_levels.stderr     | 2 +-
 tests/ui/lint/rustdoc-renamed.stderr                          | 2 +-
 tests/ui/lint/unaligned_references_external_macro.stderr      | 2 +-
 tests/ui/lint/unconditional_panic_98444.stderr                | 2 +-
 tests/ui/lint/unused/issue-105061.stderr                      | 2 +-
 tests/ui/lint/unused/issue-30730.stderr                       | 2 +-
 tests/ui/lint/unused/issue-46576.stderr                       | 2 +-
 tests/ui/lint/unused/issue-59896.stderr                       | 2 +-
 tests/ui/lint/unused/issue-85913.stderr                       | 2 +-
 tests/ui/lint/unused/lint-unused-mut-variables.stderr         | 2 +-
 tests/ui/lint/unused/unused-macro-rules-malformed-rule.stderr | 2 +-
 tests/ui/lint/unused/unused-macro-with-bad-frag-spec.stderr   | 2 +-
 .../ui/lint/unused/unused-macro-with-follow-violation.stderr  | 2 +-
 tests/ui/lint/unused/unused-mut-warning-captured-var.stderr   | 2 +-
 tests/ui/lint/unused/unused-supertrait.stderr                 | 2 +-
 tests/ui/lint/unused_parens_json_suggestion.stderr            | 2 +-
 tests/ui/lint/unused_parens_multibyte_recovery.stderr         | 2 +-
 tests/ui/lint/unused_variables-issue-82488.stderr             | 2 +-
 .../liveness-assign/liveness-assign-imm-local-in-loop.stderr  | 2 +-
 .../liveness-assign/liveness-assign-imm-local-in-op-eq.stderr | 2 +-
 .../liveness-assign-imm-local-with-drop.stderr                | 2 +-
 .../liveness-assign-imm-local-with-init.stderr                | 2 +-
 tests/ui/liveness/liveness-closure-require-ret.stderr         | 2 +-
 tests/ui/liveness/liveness-forgot-ret.stderr                  | 2 +-
 tests/ui/liveness/liveness-issue-2163.stderr                  | 2 +-
 tests/ui/liveness/liveness-missing-ret2.stderr                | 2 +-
 tests/ui/liveness/liveness-move-call-arg-2.stderr             | 2 +-
 tests/ui/liveness/liveness-move-call-arg.stderr               | 2 +-
 tests/ui/liveness/liveness-move-in-loop.stderr                | 2 +-
 tests/ui/liveness/liveness-move-in-while.stderr               | 2 +-
 tests/ui/liveness/liveness-use-after-move.stderr              | 2 +-
 tests/ui/liveness/liveness-use-after-send.stderr              | 2 +-
 tests/ui/loops/issue-82916.stderr                             | 2 +-
 tests/ui/loops/loop-break-value-no-repeat.stderr              | 2 +-
 tests/ui/loops/loop-else-break-with-value.stderr              | 2 +-
 tests/ui/loops/loop-else-err.stderr                           | 2 +-
 tests/ui/loops/loop-else-let-else-err.stderr                  | 2 +-
 tests/ui/loops/loop-proper-liveness.stderr                    | 2 +-
 tests/ui/loops/loop-properly-diverging-2.stderr               | 2 +-
 tests/ui/lto/issue-11154.stderr                               | 2 +-
 tests/ui/lto/lto-duplicate-symbols.stderr                     | 2 +-
 tests/ui/lub-glb/old-lub-glb-hr-noteq1.leak.stderr            | 2 +-
 tests/ui/lub-glb/old-lub-glb-hr-noteq1.noleak.stderr          | 2 +-
 tests/ui/lub-glb/old-lub-glb-hr-noteq2.leak.stderr            | 2 +-
 tests/ui/macros/bad-concat.stderr                             | 2 +-
 tests/ui/macros/bang-after-name.stderr                        | 2 +-
 tests/ui/macros/best-failure.stderr                           | 2 +-
 tests/ui/macros/derive-in-eager-expansion-hang.stderr         | 2 +-
 tests/ui/macros/duplicate-builtin.stderr                      | 2 +-
 tests/ui/macros/include-single-expr.stderr                    | 2 +-
 tests/ui/macros/issue-100199.stderr                           | 2 +-
 tests/ui/macros/issue-102878.stderr                           | 2 +-
 tests/ui/macros/issue-105011.stderr                           | 2 +-
 tests/ui/macros/issue-109237.stderr                           | 2 +-
 tests/ui/macros/issue-16098.stderr                            | 2 +-
 tests/ui/macros/issue-19163.stderr                            | 2 +-
 tests/ui/macros/issue-21356.stderr                            | 2 +-
 tests/ui/macros/issue-26094.stderr                            | 2 +-
 tests/ui/macros/issue-29084.stderr                            | 2 +-
 tests/ui/macros/issue-35450.stderr                            | 2 +-
 tests/ui/macros/issue-39388.stderr                            | 2 +-
 tests/ui/macros/issue-39404.stderr                            | 2 +-
 tests/ui/macros/issue-41776.stderr                            | 2 +-
 tests/ui/macros/issue-42954.stderr                            | 2 +-
 tests/ui/macros/issue-54441.stderr                            | 2 +-
 tests/ui/macros/issue-58490.stderr                            | 2 +-
 tests/ui/macros/issue-61053-duplicate-binder.stderr           | 2 +-
 tests/ui/macros/issue-6596-1.stderr                           | 2 +-
 tests/ui/macros/issue-78325-inconsistent-resolution.stderr    | 2 +-
 tests/ui/macros/issue-83340.stderr                            | 2 +-
 tests/ui/macros/issue-83344.stderr                            | 2 +-
 tests/ui/macros/issue-84195-lint-anon-const.stderr            | 2 +-
 .../macros/issue-84632-eager-expansion-recursion-limit.stderr | 2 +-
 tests/ui/macros/issue-92267.stderr                            | 2 +-
 tests/ui/macros/macro-attribute.stderr                        | 2 +-
 tests/ui/macros/macro-backtrace-println.stderr                | 2 +-
 tests/ui/macros/macro-crate-nonterminal-non-root.stderr       | 2 +-
 tests/ui/macros/macro-in-expression-context-2.stderr          | 2 +-
 tests/ui/macros/macro-in-expression-context.stderr            | 2 +-
 tests/ui/macros/macro-inner-attributes.stderr                 | 2 +-
 tests/ui/macros/macro-interpolation.stderr                    | 2 +-
 tests/ui/macros/macro-invalid-fragment-spec.stderr            | 2 +-
 tests/ui/macros/macro-local-data-key-priv.stderr              | 2 +-
 tests/ui/macros/macro-missing-delimiters.stderr               | 2 +-
 tests/ui/macros/macro-missing-fragment.stderr                 | 2 +-
 tests/ui/macros/macro-name-typo.stderr                        | 2 +-
 tests/ui/macros/macro-non-lifetime.stderr                     | 2 +-
 tests/ui/macros/macro-outer-attributes.stderr                 | 2 +-
 tests/ui/macros/macro-parameter-span.stderr                   | 2 +-
 tests/ui/macros/macro-path-prelude-fail-2.stderr              | 2 +-
 tests/ui/macros/macro-path-prelude-fail-3.stderr              | 2 +-
 tests/ui/macros/macro-path-prelude-fail-4.stderr              | 2 +-
 tests/ui/macros/macro-path-prelude-shadowing.stderr           | 2 +-
 tests/ui/macros/macro-use-bad-args-1.stderr                   | 2 +-
 tests/ui/macros/macro-use-bad-args-2.stderr                   | 2 +-
 tests/ui/macros/macro-use-undef.stderr                        | 2 +-
 tests/ui/macros/macro-use-wrong-name.stderr                   | 2 +-
 tests/ui/macros/macro_path_as_generic_bound.stderr            | 2 +-
 tests/ui/macros/macro_undefined.stderr                        | 2 +-
 tests/ui/macros/malformed_macro_lhs.stderr                    | 2 +-
 tests/ui/macros/meta-variable-depth-outside-repeat.stderr     | 2 +-
 tests/ui/macros/nonterminal-matching.stderr                   | 2 +-
 tests/ui/macros/not-utf8.stderr                               | 2 +-
 tests/ui/macros/out-of-order-shadowing.stderr                 | 2 +-
 tests/ui/macros/recovery-allowed.stderr                       | 2 +-
 tests/ui/macros/span-covering-argument-1.stderr               | 2 +-
 tests/ui/macros/unreachable-arg.edition_2021.stderr           | 2 +-
 tests/ui/macros/unreachable-format-args.edition_2015.stderr   | 2 +-
 tests/ui/macros/vec-macro-in-pattern.stderr                   | 2 +-
 tests/ui/main-wrong-location.stderr                           | 2 +-
 tests/ui/main-wrong-type.stderr                               | 2 +-
 .../issue-107423-unused-delim-only-one-no-pair.stderr         | 2 +-
 tests/ui/malformed/issue-69341-malformed-derive-inert.stderr  | 2 +-
 tests/ui/manual/manual-link-framework.stderr                  | 2 +-
 tests/ui/marker_trait_attr/overlap-marker-trait.stderr        | 2 +-
 .../overlapping-impl-1-modulo-regions.stderr                  | 2 +-
 tests/ui/marker_trait_attr/unsound-overlap.stderr             | 2 +-
 tests/ui/match/issue-11319.stderr                             | 2 +-
 tests/ui/match/issue-70972-dyn-trait.stderr                   | 2 +-
 tests/ui/match/issue-74050-end-span.stderr                    | 2 +-
 tests/ui/match/issue-91058.stderr                             | 2 +-
 tests/ui/match/issue-92100.stderr                             | 2 +-
 tests/ui/match/match-arm-resolving-to-never.stderr            | 2 +-
 tests/ui/match/match-ill-type2.stderr                         | 2 +-
 tests/ui/match/match-join.stderr                              | 2 +-
 tests/ui/match/match-no-arms-unreachable-after.stderr         | 2 +-
 tests/ui/match/match-pattern-field-mismatch-2.stderr          | 2 +-
 tests/ui/match/match-pattern-field-mismatch.stderr            | 2 +-
 tests/ui/match/match-ref-mut-invariance.stderr                | 2 +-
 tests/ui/match/match-ref-mut-let-invariance.stderr            | 2 +-
 tests/ui/match/match-struct.stderr                            | 2 +-
 tests/ui/match/match-tag-nullary.stderr                       | 2 +-
 tests/ui/match/match-tag-unary.stderr                         | 2 +-
 tests/ui/match/match-unresolved-one-arm.stderr                | 2 +-
 tests/ui/match/match-vec-mismatch-2.stderr                    | 2 +-
 .../non-first-arm-doesnt-match-expected-return-type.stderr    | 2 +-
 tests/ui/match/single-line.stderr                             | 2 +-
 tests/ui/meta/expected-error-correct-rev.a.stderr             | 2 +-
 tests/ui/meta/meta-expected-error-wrong-rev.a.stderr          | 2 +-
 tests/ui/methods/issue-3707.stderr                            | 2 +-
 tests/ui/methods/issues/issue-84495.stderr                    | 2 +-
 tests/ui/methods/issues/issue-94581.stderr                    | 2 +-
 tests/ui/methods/method-ambig-two-traits-cross-crate.stderr   | 2 +-
 tests/ui/methods/method-ambig-two-traits-from-bounds.stderr   | 2 +-
 tests/ui/methods/method-ambig-two-traits-from-impls.stderr    | 2 +-
 tests/ui/methods/method-ambig-two-traits-from-impls2.stderr   | 2 +-
 .../method-ambig-two-traits-with-default-method.stderr        | 2 +-
 tests/ui/methods/method-ambiguity-no-rcvr.stderr              | 2 +-
 tests/ui/methods/method-call-lifetime-args-unresolved.stderr  | 2 +-
 tests/ui/methods/method-call-type-binding.stderr              | 2 +-
 tests/ui/methods/method-macro-backtrace.stderr                | 2 +-
 tests/ui/methods/method-not-found-but-doc-alias.stderr        | 2 +-
 tests/ui/methods/method-resolvable-path-in-pattern.stderr     | 2 +-
 .../ui/methods/suggest-method-on-call-with-macro-rcvr.stderr  | 2 +-
 tests/ui/minus-string.stderr                                  | 2 +-
 tests/ui/mir/build-async-error-body-correctly.stderr          | 2 +-
 tests/ui/mir/field-projection-mutating-context.stderr         | 2 +-
 tests/ui/mir/field-projection-mutating-context2.stderr        | 2 +-
 tests/ui/mir/issue-102389.stderr                              | 2 +-
 tests/ui/mir/issue-106062.stderr                              | 2 +-
 tests/ui/mir/issue-75053.stderr                               | 2 +-
 tests/ui/mir/issue-92893.stderr                               | 2 +-
 .../mismatched_types/assignment-operator-unimplemented.stderr | 2 +-
 .../closure-arg-count-expected-type-issue-47244.stderr        | 2 +-
 tests/ui/mismatched_types/closure-ref-114180.stderr           | 2 +-
 tests/ui/mismatched_types/dont-point-return-on-E0308.stderr   | 2 +-
 tests/ui/mismatched_types/for-loop-has-unit-body.stderr       | 2 +-
 tests/ui/mismatched_types/issue-106182.stderr                 | 2 +-
 tests/ui/mismatched_types/issue-112036.stderr                 | 2 +-
 tests/ui/mismatched_types/issue-13033.stderr                  | 2 +-
 tests/ui/mismatched_types/issue-19109.stderr                  | 2 +-
 tests/ui/mismatched_types/issue-35030.stderr                  | 2 +-
 tests/ui/mismatched_types/issue-47706-trait.stderr            | 2 +-
 tests/ui/mismatched_types/issue-75361-mismatched-impl.stderr  | 2 +-
 tests/ui/mismatched_types/main.stderr                         | 2 +-
 .../ui/mismatched_types/method-help-unsatisfied-bound.stderr  | 2 +-
 tests/ui/mismatched_types/normalize-fn-sig.stderr             | 2 +-
 tests/ui/mismatched_types/recovered-block.stderr              | 2 +-
 tests/ui/mismatched_types/show_module.stderr                  | 2 +-
 tests/ui/mismatched_types/similar_paths.stderr                | 2 +-
 tests/ui/mismatched_types/similar_paths_primitive.stderr      | 2 +-
 .../suggest-option-asderef-inference-var.stderr               | 2 +-
 tests/ui/mismatched_types/trait-bounds-cant-coerce.stderr     | 2 +-
 .../mismatched_types/unboxed-closures-vtable-mismatch.stderr  | 2 +-
 tests/ui/missing-trait-bounds/issue-35677.stderr              | 2 +-
 tests/ui/missing-trait-bounds/issue-69725.stderr              | 2 +-
 .../ui/missing-trait-bounds/missing-trait-bound-for-op.stderr | 2 +-
 tests/ui/missing/missing-allocator.stderr                     | 2 +-
 tests/ui/missing/missing-comma-in-match.stderr                | 2 +-
 tests/ui/missing/missing-derivable-attr.stderr                | 2 +-
 tests/ui/missing/missing-fields-in-struct-pattern.stderr      | 2 +-
 tests/ui/missing/missing-items/m2.stderr                      | 2 +-
 tests/ui/missing/missing-items/missing-type-parameter.stderr  | 2 +-
 tests/ui/missing/missing-macro-use.stderr                     | 2 +-
 tests/ui/missing/missing-main.stderr                          | 2 +-
 tests/ui/missing/missing-return.stderr                        | 2 +-
 tests/ui/missing_non_modrs_mod/missing_non_modrs_mod.stderr   | 2 +-
 .../missing_non_modrs_mod/missing_non_modrs_mod_inline.stderr | 2 +-
 tests/ui/mod-subitem-as-enum-variant.stderr                   | 2 +-
 tests/ui/module-macro_use-arguments.stderr                    | 2 +-
 tests/ui/modules/issue-107649.stderr                          | 2 +-
 tests/ui/modules/path-invalid-form.stderr                     | 2 +-
 tests/ui/modules/path-macro.stderr                            | 2 +-
 tests/ui/modules/path-no-file-name.stderr                     | 2 +-
 .../mod_file_correct_spans.stderr                             | 2 +-
 tests/ui/moves/issue-34721.stderr                             | 2 +-
 tests/ui/moves/issue-46099-move-in-macro.stderr               | 2 +-
 tests/ui/moves/issue-75904-move-closure-loop.stderr           | 2 +-
 tests/ui/moves/issue-99470-move-out-of-some.stderr            | 2 +-
 tests/ui/moves/move-guard-same-consts.stderr                  | 2 +-
 tests/ui/moves/move-in-guard-1.stderr                         | 2 +-
 tests/ui/moves/move-in-guard-2.stderr                         | 2 +-
 tests/ui/moves/move-into-dead-array-1.stderr                  | 2 +-
 tests/ui/moves/move-into-dead-array-2.stderr                  | 2 +-
 tests/ui/moves/move-of-addr-of-mut.stderr                     | 2 +-
 tests/ui/moves/move-out-of-array-1.stderr                     | 2 +-
 tests/ui/moves/move-out-of-slice-1.stderr                     | 2 +-
 tests/ui/moves/moves-based-on-type-access-to-field.stderr     | 2 +-
 tests/ui/moves/moves-based-on-type-block-bad.stderr           | 2 +-
 tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr  | 2 +-
 .../moves/moves-based-on-type-cyclic-types-issue-4821.stderr  | 2 +-
 tests/ui/moves/moves-based-on-type-match-bindings.stderr      | 2 +-
 ...es-based-on-type-move-out-of-closure-env-issue-1965.stderr | 2 +-
 tests/ui/moves/moves-based-on-type-tuple.stderr               | 2 +-
 tests/ui/moves/moves-sru-moved-field.stderr                   | 2 +-
 tests/ui/moves/pin-mut-reborrow-infer-var-issue-107419.stderr | 2 +-
 tests/ui/moves/pin-mut-reborrow.stderr                        | 2 +-
 tests/ui/moves/suggest-clone.stderr                           | 2 +-
 tests/ui/moves/use_of_moved_value_clone_suggestions.stderr    | 2 +-
 tests/ui/mut/mut-cant-alias.stderr                            | 2 +-
 tests/ui/mut/mut-cross-borrowing.stderr                       | 2 +-
 tests/ui/mut/mut-ref.stderr                                   | 2 +-
 tests/ui/mut/mutable-class-fields-2.stderr                    | 2 +-
 tests/ui/mut/mutable-class-fields.stderr                      | 2 +-
 tests/ui/mut/mutable-enum-indirect.stderr                     | 2 +-
 .../ui/native-library-link-flags/modifiers-override-3.stderr  | 2 +-
 .../native-library-link-flags/suggest-libname-only-1.stderr   | 2 +-
 .../native-library-link-flags/suggest-libname-only-2.stderr   | 2 +-
 tests/ui/nested-cfg-attrs.stderr                              | 2 +-
 tests/ui/never_type/call-fn-never-arg-wrong-type.stderr       | 2 +-
 tests/ui/never_type/defaulted-never-note.fallback.stderr      | 2 +-
 .../ui/never_type/diverging-fallback-no-leak.fallback.stderr  | 2 +-
 tests/ui/never_type/exhaustive_patterns.stderr                | 2 +-
 tests/ui/never_type/fallback-closure-wrap.fallback.stderr     | 2 +-
 tests/ui/never_type/feature-gate-never_type_fallback.stderr   | 2 +-
 tests/ui/never_type/impl_trait_fallback3.stderr               | 2 +-
 tests/ui/never_type/impl_trait_fallback4.stderr               | 2 +-
 tests/ui/never_type/issue-10176.stderr                        | 2 +-
 tests/ui/never_type/issue-13352.stderr                        | 2 +-
 tests/ui/never_type/issue-51506.stderr                        | 2 +-
 tests/ui/never_type/never-assign-wrong-type.stderr            | 2 +-
 .../ui/never_type/never-from-impl-is-reserved.current.stderr  | 2 +-
 tests/ui/never_type/never-from-impl-is-reserved.next.stderr   | 2 +-
 .../never-value-fallback-issue-66757.nofallback.stderr        | 2 +-
 tests/ui/nll/borrowed-local-error.stderr                      | 2 +-
 tests/ui/nll/borrowed-match-issue-45045.stderr                | 2 +-
 tests/ui/nll/borrowed-referent-issue-38899.stderr             | 2 +-
 tests/ui/nll/borrowed-temporary-error.stderr                  | 2 +-
 tests/ui/nll/borrowed-universal-error-2.stderr                | 2 +-
 tests/ui/nll/borrowed-universal-error.stderr                  | 2 +-
 tests/ui/nll/capture-mut-ref.stderr                           | 2 +-
 tests/ui/nll/capture-ref-in-struct.stderr                     | 2 +-
 .../ui/nll/closure-requirements/escape-argument-callee.stderr | 2 +-
 tests/ui/nll/closure-requirements/escape-argument.stderr      | 2 +-
 tests/ui/nll/closure-requirements/escape-upvar-nested.stderr  | 2 +-
 tests/ui/nll/closure-requirements/escape-upvar-ref.stderr     | 2 +-
 .../propagate-approximated-fail-no-postdom.stderr             | 2 +-
 .../closure-requirements/propagate-approximated-ref.stderr    | 2 +-
 .../propagate-approximated-shorter-to-static-no-bound.stderr  | 2 +-
 ...ropagate-approximated-shorter-to-static-wrong-bound.stderr | 2 +-
 .../closure-requirements/propagate-approximated-val.stderr    | 2 +-
 .../propagate-fail-to-approximate-longer-no-bounds.stderr     | 2 +-
 .../propagate-fail-to-approximate-longer-wrong-bounds.stderr  | 2 +-
 .../closure-requirements/propagate-from-trait-match.stderr    | 2 +-
 .../propagate-multiple-requirements.stderr                    | 2 +-
 .../region-lbr-anon-does-not-outlive-static.stderr            | 2 +-
 .../region-lbr-named-does-not-outlive-static.stderr           | 2 +-
 .../region-lbr1-does-not-outlive-ebr2.stderr                  | 2 +-
 .../nll/closure-requirements/return-wrong-bound-region.stderr | 2 +-
 tests/ui/nll/constant-thread-locals-issue-47053.stderr        | 2 +-
 tests/ui/nll/continue-after-missing-main.stderr               | 2 +-
 tests/ui/nll/coroutine-upvar-mutability.stderr                | 2 +-
 tests/ui/nll/decl-macro-illegal-copy.stderr                   | 2 +-
 .../ui/nll/do-not-ignore-lifetime-bounds-in-copy-proj.stderr  | 2 +-
 tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy.stderr     | 2 +-
 tests/ui/nll/issue-27282-mutate-before-diverging-arm-1.stderr | 2 +-
 tests/ui/nll/issue-27282-mutate-before-diverging-arm-2.stderr | 2 +-
 tests/ui/nll/issue-27282-mutate-before-diverging-arm-3.stderr | 2 +-
 tests/ui/nll/issue-27868.stderr                               | 2 +-
 tests/ui/nll/issue-30438-a.stderr                             | 2 +-
 tests/ui/nll/issue-30438-b.stderr                             | 2 +-
 tests/ui/nll/issue-30438-c.stderr                             | 2 +-
 tests/ui/nll/issue-31567.stderr                               | 2 +-
 tests/ui/nll/issue-45157.stderr                               | 2 +-
 tests/ui/nll/issue-46023.stderr                               | 2 +-
 tests/ui/nll/issue-46036.stderr                               | 2 +-
 tests/ui/nll/issue-46589.stderr                               | 2 +-
 tests/ui/nll/issue-47388.stderr                               | 2 +-
 tests/ui/nll/issue-47470.stderr                               | 2 +-
 tests/ui/nll/issue-48238.stderr                               | 2 +-
 tests/ui/nll/issue-48697.stderr                               | 2 +-
 tests/ui/nll/issue-48803.stderr                               | 2 +-
 tests/ui/nll/issue-50716.stderr                               | 2 +-
 tests/ui/nll/issue-51244.stderr                               | 2 +-
 tests/ui/nll/issue-51268.stderr                               | 2 +-
 tests/ui/nll/issue-51512.stderr                               | 2 +-
 tests/ui/nll/issue-52113.stderr                               | 2 +-
 tests/ui/nll/issue-52213.stderr                               | 2 +-
 tests/ui/nll/issue-52533-1.stderr                             | 2 +-
 tests/ui/nll/issue-52534-2.stderr                             | 2 +-
 tests/ui/nll/issue-52663-span-decl-captured-variable.stderr   | 2 +-
 tests/ui/nll/issue-52663-trait-object.stderr                  | 2 +-
 tests/ui/nll/issue-52669.stderr                               | 2 +-
 tests/ui/nll/issue-52742.stderr                               | 2 +-
 tests/ui/nll/issue-53040.stderr                               | 2 +-
 tests/ui/nll/issue-53773.stderr                               | 2 +-
 tests/ui/nll/issue-53807.stderr                               | 2 +-
 tests/ui/nll/issue-54189.stderr                               | 2 +-
 tests/ui/nll/issue-54302.stderr                               | 2 +-
 tests/ui/nll/issue-54382-use-span-of-tail-of-block.stderr     | 2 +-
 tests/ui/nll/issue-54556-niconii.stderr                       | 2 +-
 tests/ui/nll/issue-54556-stephaneyfx.stderr                   | 2 +-
 tests/ui/nll/issue-54556-temps-in-tail-diagnostic.stderr      | 2 +-
 tests/ui/nll/issue-54556-wrap-it-up.stderr                    | 2 +-
 tests/ui/nll/issue-54779-anon-static-lifetime.stderr          | 2 +-
 tests/ui/nll/issue-54943.stderr                               | 2 +-
 tests/ui/nll/issue-55394.stderr                               | 2 +-
 tests/ui/nll/issue-55401.stderr                               | 2 +-
 tests/ui/nll/issue-55511.stderr                               | 2 +-
 tests/ui/nll/issue-57265-return-type-wf-check.stderr          | 2 +-
 tests/ui/nll/issue-57280-1-flipped.stderr                     | 2 +-
 tests/ui/nll/issue-57843.stderr                               | 2 +-
 tests/ui/nll/issue-61424.stderr                               | 2 +-
 tests/ui/nll/issue-67007-escaping-data.stderr                 | 2 +-
 tests/ui/nll/issue-68550.stderr                               | 2 +-
 tests/ui/nll/issue-69114-static-ty.stderr                     | 2 +-
 tests/ui/nll/issue-73159-rpit-static.stderr                   | 2 +-
 tests/ui/nll/issue-75777.stderr                               | 2 +-
 tests/ui/nll/issue-95272.stderr                               | 2 +-
 tests/ui/nll/issue-98693.stderr                               | 2 +-
 tests/ui/nll/loan_ends_mid_block_pair.stderr                  | 2 +-
 tests/ui/nll/match-cfg-fake-edges2.stderr                     | 2 +-
 .../nll/maybe-initialized-drop-implicit-fragment-drop.stderr  | 2 +-
 tests/ui/nll/maybe-initialized-drop-with-fragment.stderr      | 2 +-
 ...maybe-initialized-drop-with-uninitialized-fragments.stderr | 2 +-
 tests/ui/nll/maybe-initialized-drop.stderr                    | 2 +-
 tests/ui/nll/mir_check_cast_closure.stderr                    | 2 +-
 tests/ui/nll/mir_check_cast_reify.stderr                      | 2 +-
 tests/ui/nll/mir_check_cast_unsafe_fn.stderr                  | 2 +-
 tests/ui/nll/mir_check_cast_unsize.stderr                     | 2 +-
 tests/ui/nll/move-subpaths-moves-root.stderr                  | 2 +-
 tests/ui/nll/normalization-bounds-error.stderr                | 2 +-
 tests/ui/nll/polonius/subset-relations.stderr                 | 2 +-
 tests/ui/nll/promoted-bounds.stderr                           | 2 +-
 tests/ui/nll/promoted-closure-pair.stderr                     | 2 +-
 tests/ui/nll/reference-carried-through-struct-field.stderr    | 2 +-
 tests/ui/nll/region-ends-after-if-condition.stderr            | 2 +-
 tests/ui/nll/relate_tys/fn-subtype.stderr                     | 2 +-
 tests/ui/nll/relate_tys/opaque-hrtb.stderr                    | 2 +-
 tests/ui/nll/relate_tys/trait-hrtb.stderr                     | 2 +-
 tests/ui/nll/relate_tys/universe-violation.stderr             | 2 +-
 tests/ui/nll/relate_tys/var-appears-twice.stderr              | 2 +-
 tests/ui/nll/return-ref-mut-issue-46557.stderr                | 2 +-
 tests/ui/nll/return_from_loop.stderr                          | 2 +-
 tests/ui/nll/snocat-regression.stderr                         | 2 +-
 tests/ui/nll/trait-associated-constant.stderr                 | 2 +-
 tests/ui/nll/ty-outlives/impl-trait-captures.stderr           | 2 +-
 tests/ui/nll/ty-outlives/projection-implied-bounds.stderr     | 2 +-
 .../projection-where-clause-env-wrong-bound.stderr            | 2 +-
 .../projection-where-clause-env-wrong-lifetime.stderr         | 2 +-
 tests/ui/nll/ty-outlives/projection-where-clause-none.stderr  | 2 +-
 .../ty-param-closure-approximate-lower-bound.stderr           | 2 +-
 tests/ui/nll/ty-outlives/ty-param-fn-body.stderr              | 2 +-
 tests/ui/nll/unused-mut-issue-50343.stderr                    | 2 +-
 tests/ui/nll/user-annotations/ascribed-type-wf.stderr         | 2 +-
 tests/ui/nll/user-annotations/cast_static_lifetime.stderr     | 2 +-
 .../nll/user-annotations/constant-in-expr-inherent-1.stderr   | 2 +-
 .../ui/nll/user-annotations/constant-in-expr-normalize.stderr | 2 +-
 .../nll/user-annotations/constant-in-expr-trait-item-1.stderr | 2 +-
 .../nll/user-annotations/constant-in-expr-trait-item-2.stderr | 2 +-
 .../nll/user-annotations/constant-in-expr-trait-item-3.stderr | 2 +-
 tests/ui/nll/user-annotations/dump-adt-brace-struct.stderr    | 2 +-
 .../nll/user-annotations/inherent-associated-constants.stderr | 2 +-
 tests/ui/nll/user-annotations/method-ufcs-inherent-1.stderr   | 2 +-
 tests/ui/nll/user-annotations/method-ufcs-inherent-3.stderr   | 2 +-
 tests/ui/nll/user-annotations/promoted-annotation.stderr      | 2 +-
 .../user-annotations/type_ascription_static_lifetime.stderr   | 2 +-
 tests/ui/nll/user-annotations/wf-self-type.stderr             | 2 +-
 tests/ui/nll/where_clauses_in_functions.stderr                | 2 +-
 tests/ui/nll/where_clauses_in_structs.stderr                  | 2 +-
 tests/ui/no-capture-arc.stderr                                | 2 +-
 tests/ui/no-link-unknown-crate.stderr                         | 2 +-
 tests/ui/no-reuse-move-arc.stderr                             | 2 +-
 tests/ui/no-send-res-ports.stderr                             | 2 +-
 tests/ui/no_crate_type.stderr                                 | 2 +-
 tests/ui/no_send-enum.stderr                                  | 2 +-
 tests/ui/no_send-rc.stderr                                    | 2 +-
 tests/ui/no_share-enum.stderr                                 | 2 +-
 tests/ui/no_share-struct.stderr                               | 2 +-
 tests/ui/noexporttypeexe.stderr                               | 2 +-
 tests/ui/non-constant-expr-for-arr-len.stderr                 | 2 +-
 tests/ui/non-copyable-void.stderr                             | 2 +-
 tests/ui/noncopyable-class.stderr                             | 2 +-
 tests/ui/nonscalar-cast.stderr                                | 2 +-
 tests/ui/not-clone-closure.stderr                             | 2 +-
 tests/ui/not-copy-closure.stderr                              | 2 +-
 tests/ui/not-panic/not-panic-safe-5.stderr                    | 2 +-
 tests/ui/not-panic/not-panic-safe.stderr                      | 2 +-
 tests/ui/numbers-arithmetic/overflowing-lsh-1.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-lsh-2.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-lsh-3.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-lsh-4.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-rsh-1.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-rsh-2.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-rsh-3.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-rsh-4.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-rsh-5.stderr          | 2 +-
 tests/ui/numbers-arithmetic/overflowing-rsh-6.stderr          | 2 +-
 tests/ui/numeric/len.stderr                                   | 2 +-
 .../object-lifetime-default-dyn-binding-nonstatic1.stderr     | 2 +-
 .../object-lifetime-default-dyn-binding-nonstatic2.stderr     | 2 +-
 .../object-lifetime-default-dyn-binding-nonstatic3.stderr     | 2 +-
 .../ui/object-lifetime/object-lifetime-default-elision.stderr | 2 +-
 .../object-lifetime-default-from-rptr-box-error.stderr        | 2 +-
 .../object-lifetime-default-from-rptr-struct-error.stderr     | 2 +-
 .../ui/object-safety/assoc_type_bounds_implicit_sized.stderr  | 2 +-
 tests/ui/object-safety/issue-102762.stderr                    | 2 +-
 .../object-safety/object-safety-associated-consts.curr.stderr | 2 +-
 ...t-safety-associated-consts.object_safe_for_dispatch.stderr | 2 +-
 tests/ui/object-safety/object-safety-bounds.stderr            | 2 +-
 tests/ui/object-safety/object-safety-by-value-self-use.stderr | 2 +-
 tests/ui/object-safety/object-safety-issue-22040.stderr       | 2 +-
 tests/ui/object-safety/object-safety-no-static.curr.stderr    | 2 +-
 .../object-safety-no-static.object_safe_for_dispatch.stderr   | 2 +-
 tests/ui/object-safety/object-safety-sized-2.curr.stderr      | 2 +-
 .../object-safety-sized-2.object_safe_for_dispatch.stderr     | 2 +-
 tests/ui/object-safety/object-safety-sized.curr.stderr        | 2 +-
 .../object-safety-sized.object_safe_for_dispatch.stderr       | 2 +-
 .../object-safety-supertrait-mentions-Self.stderr             | 2 +-
 tests/ui/occurs-check-2.stderr                                | 2 +-
 tests/ui/occurs-check-3.stderr                                | 2 +-
 tests/ui/occurs-check.stderr                                  | 2 +-
 tests/ui/offset-of/offset-of-inference.stderr                 | 2 +-
 tests/ui/on-unimplemented/expected-comma-found-token.stderr   | 2 +-
 .../ui/on-unimplemented/feature-gate-on-unimplemented.stderr  | 2 +-
 tests/ui/on-unimplemented/impl-substs.stderr                  | 2 +-
 tests/ui/on-unimplemented/issue-104140.stderr                 | 2 +-
 tests/ui/once-cant-call-twice-on-heap.stderr                  | 2 +-
 tests/ui/operator-recovery/less-than-greater-than.stderr      | 2 +-
 tests/ui/operator-recovery/spaceship.stderr                   | 2 +-
 tests/ui/or-patterns/fn-param-wrap-parens.stderr              | 2 +-
 tests/ui/or-patterns/inner-or-pat.or3.stderr                  | 2 +-
 tests/ui/or-patterns/inner-or-pat.or4.stderr                  | 2 +-
 tests/ui/or-patterns/while-parsing-this-or-pattern.stderr     | 2 +-
 tests/ui/order-dependent-cast-inference.stderr                | 2 +-
 tests/ui/orphan-check-diagnostics.stderr                      | 2 +-
 tests/ui/osx-frameworks.stderr                                | 2 +-
 tests/ui/packed-struct/packed-struct-generic-transmute.stderr | 2 +-
 tests/ui/packed-struct/packed-struct-transmute.stderr         | 2 +-
 tests/ui/packed/issue-27060-2.stderr                          | 2 +-
 tests/ui/packed/packed-struct-borrow-element-64bit.stderr     | 2 +-
 tests/ui/panic-handler/panic-handler-bad-signature-1.stderr   | 2 +-
 tests/ui/panic-handler/panic-handler-bad-signature-2.stderr   | 2 +-
 tests/ui/panic-handler/panic-handler-bad-signature-3.stderr   | 2 +-
 tests/ui/panic-handler/panic-handler-bad-signature-4.stderr   | 2 +-
 tests/ui/panic-handler/panic-handler-bad-signature-5.stderr   | 2 +-
 tests/ui/panic-handler/panic-handler-duplicate.stderr         | 2 +-
 .../ui/panic-handler/panic-handler-requires-panic-info.stderr | 2 +-
 tests/ui/panic-handler/panic-handler-std.stderr               | 2 +-
 .../ui/panic-handler/panic-handler-with-target-feature.stderr | 2 +-
 tests/ui/panic-runtime/abort-link-to-unwind-dylib.stderr      | 2 +-
 tests/ui/panic-runtime/need-abort-got-unwind.stderr           | 2 +-
 tests/ui/panic-runtime/need-unwind-got-abort.stderr           | 2 +-
 tests/ui/panic-runtime/want-unwind-got-abort.stderr           | 2 +-
 tests/ui/paren-span.stderr                                    | 2 +-
 tests/ui/parser/assoc/assoc-oddities-1.stderr                 | 2 +-
 tests/ui/parser/assoc/assoc-oddities-2.stderr                 | 2 +-
 tests/ui/parser/assoc/assoc-type-in-type-arg.stderr           | 2 +-
 tests/ui/parser/attribute/attr-bad-meta-2.stderr              | 2 +-
 tests/ui/parser/attribute/attr-bad-meta-3.stderr              | 2 +-
 tests/ui/parser/attribute/attr-bad-meta.stderr                | 2 +-
 tests/ui/parser/attribute/attr-before-eof.stderr              | 2 +-
 tests/ui/parser/attribute/attr-dangling-in-fn.stderr          | 2 +-
 tests/ui/parser/attribute/attr-dangling-in-mod.stderr         | 2 +-
 tests/ui/parser/attribute/attr-with-a-semicolon.stderr        | 2 +-
 tests/ui/parser/attribute/attr.stderr                         | 2 +-
 .../attribute-with-no-generics-in-parameter-list.stderr       | 2 +-
 tests/ui/parser/attribute/attrs-after-extern-mod.stderr       | 2 +-
 tests/ui/parser/bad-escape-suggest-raw-string.stderr          | 2 +-
 tests/ui/parser/bad-let-as-field.stderr                       | 2 +-
 tests/ui/parser/bad-match.stderr                              | 2 +-
 tests/ui/parser/bad-name.stderr                               | 2 +-
 tests/ui/parser/bad-pointer-type.stderr                       | 2 +-
 tests/ui/parser/bad-struct-following-where.stderr             | 2 +-
 tests/ui/parser/bad-value-ident-false.stderr                  | 2 +-
 tests/ui/parser/bad-value-ident-true.stderr                   | 2 +-
 tests/ui/parser/better-expected.stderr                        | 2 +-
 tests/ui/parser/bind-struct-early-modifiers.stderr            | 2 +-
 tests/ui/parser/bound-single-question-mark.stderr             | 2 +-
 tests/ui/parser/bounds-lifetime-1.stderr                      | 2 +-
 tests/ui/parser/bounds-lifetime-2.stderr                      | 2 +-
 tests/ui/parser/bounds-lifetime-where-1.stderr                | 2 +-
 tests/ui/parser/bounds-lifetime-where.stderr                  | 2 +-
 tests/ui/parser/bounds-lifetime.stderr                        | 2 +-
 tests/ui/parser/bounds-type-where.stderr                      | 2 +-
 tests/ui/parser/can-begin-expr-check.stderr                   | 2 +-
 tests/ui/parser/char/whitespace-character-literal.stderr      | 2 +-
 tests/ui/parser/class-implements-bad-trait.stderr             | 2 +-
 tests/ui/parser/closure-return-syntax.stderr                  | 2 +-
 tests/ui/parser/column-offset-1-based.stderr                  | 2 +-
 tests/ui/parser/deep-unmatched-angle-brackets.stderr          | 2 +-
 tests/ui/parser/deli-ident-issue-1.stderr                     | 2 +-
 tests/ui/parser/diff-markers/enum-2.stderr                    | 2 +-
 tests/ui/parser/diff-markers/enum.stderr                      | 2 +-
 tests/ui/parser/diff-markers/fn-arg.stderr                    | 2 +-
 tests/ui/parser/diff-markers/item-with-attr.stderr            | 2 +-
 tests/ui/parser/diff-markers/item.stderr                      | 2 +-
 tests/ui/parser/diff-markers/statement.stderr                 | 2 +-
 tests/ui/parser/diff-markers/struct-expr.stderr               | 2 +-
 tests/ui/parser/diff-markers/struct.stderr                    | 2 +-
 tests/ui/parser/diff-markers/trait-item.stderr                | 2 +-
 tests/ui/parser/diff-markers/tuple-struct.stderr              | 2 +-
 tests/ui/parser/diff-markers/unclosed-delims-in-macro.stderr  | 2 +-
 tests/ui/parser/diff-markers/unclosed-delims.stderr           | 2 +-
 tests/ui/parser/diff-markers/use-statement.stderr             | 2 +-
 tests/ui/parser/do-not-suggest-semicolon-before-array.stderr  | 2 +-
 ...on-between-macro-without-exclamation-mark-and-array.stderr | 2 +-
 tests/ui/parser/doc-before-attr.stderr                        | 2 +-
 tests/ui/parser/doc-before-eof.stderr                         | 2 +-
 tests/ui/parser/doc-before-extern-rbrace.stderr               | 2 +-
 tests/ui/parser/doc-before-fn-rbrace.stderr                   | 2 +-
 tests/ui/parser/doc-before-identifier.stderr                  | 2 +-
 tests/ui/parser/doc-before-mod-rbrace.stderr                  | 2 +-
 tests/ui/parser/doc-before-rbrace.stderr                      | 2 +-
 tests/ui/parser/doc-before-semi.stderr                        | 2 +-
 tests/ui/parser/doc-before-struct-rbrace-1.stderr             | 2 +-
 tests/ui/parser/doc-before-struct-rbrace-2.stderr             | 2 +-
 tests/ui/parser/doc-inside-trait-item.stderr                  | 2 +-
 tests/ui/parser/dotdotdot-expr.stderr                         | 2 +-
 tests/ui/parser/double-pointer.stderr                         | 2 +-
 tests/ui/parser/duplicate-visibility.stderr                   | 2 +-
 tests/ui/parser/empty-impl-semicolon.stderr                   | 2 +-
 tests/ui/parser/extern-crate-unexpected-token.stderr          | 2 +-
 tests/ui/parser/extern-expected-fn-or-brace.stderr            | 2 +-
 tests/ui/parser/extern-foreign-crate.stderr                   | 2 +-
 tests/ui/parser/extern-no-fn.stderr                           | 2 +-
 tests/ui/parser/fn-colon-return-type.stderr                   | 2 +-
 tests/ui/parser/fn-defined-using-def.stderr                   | 2 +-
 tests/ui/parser/fn-defined-using-fun.stderr                   | 2 +-
 tests/ui/parser/fn-defined-using-func.stderr                  | 2 +-
 tests/ui/parser/fn-defined-using-function.stderr              | 2 +-
 tests/ui/parser/generic-statics.stderr                        | 2 +-
 tests/ui/parser/if-in-in.stderr                               | 2 +-
 tests/ui/parser/impl-item-const-semantic-fail.stderr          | 2 +-
 tests/ui/parser/impl-item-fn-no-body-semantic-fail.stderr     | 2 +-
 tests/ui/parser/impl-on-unsized-typo.stderr                   | 2 +-
 tests/ui/parser/import-from-path.stderr                       | 2 +-
 tests/ui/parser/import-from-rename.stderr                     | 2 +-
 tests/ui/parser/import-glob-path.stderr                       | 2 +-
 tests/ui/parser/import-glob-rename.stderr                     | 2 +-
 tests/ui/parser/inner-attr-after-doc-comment.stderr           | 2 +-
 tests/ui/parser/inner-attr.stderr                             | 2 +-
 tests/ui/parser/int-literal-too-large-span.stderr             | 2 +-
 tests/ui/parser/integer-literal-start-ident.stderr            | 2 +-
 tests/ui/parser/intersection-patterns-2.stderr                | 2 +-
 tests/ui/parser/issues/issue-100197-mut-let.stderr            | 2 +-
 tests/ui/parser/issues/issue-101477-let.stderr                | 2 +-
 tests/ui/parser/issues/issue-101540.stderr                    | 2 +-
 tests/ui/parser/issues/issue-102182-impl-trait-recover.stderr | 2 +-
 tests/ui/parser/issues/issue-103451.stderr                    | 2 +-
 tests/ui/parser/issues/issue-10392-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-10392.stderr                     | 2 +-
 tests/ui/parser/issues/issue-104620.stderr                    | 2 +-
 tests/ui/parser/issues/issue-105366.stderr                    | 2 +-
 tests/ui/parser/issues/issue-10636-1.stderr                   | 2 +-
 tests/ui/parser/issues/issue-10636-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-107705.stderr                    | 2 +-
 .../parser/issues/issue-108109-fn-trait-missing-paren.stderr  | 2 +-
 tests/ui/parser/issues/issue-108242-semicolon-recovery.stderr | 2 +-
 tests/ui/parser/issues/issue-111148.stderr                    | 2 +-
 tests/ui/parser/issues/issue-111416.stderr                    | 2 +-
 .../parser/issues/issue-113110-non-item-at-module-root.stderr | 2 +-
 tests/ui/parser/issues/issue-113203.stderr                    | 2 +-
 tests/ui/parser/issues/issue-113342.stderr                    | 2 +-
 tests/ui/parser/issues/issue-114219.stderr                    | 2 +-
 tests/ui/parser/issues/issue-14303-fncall.full.stderr         | 2 +-
 tests/ui/parser/issues/issue-14303-fncall.generic_arg.stderr  | 2 +-
 tests/ui/parser/issues/issue-15914.stderr                     | 2 +-
 tests/ui/parser/issues/issue-15980.stderr                     | 2 +-
 tests/ui/parser/issues/issue-1655.stderr                      | 2 +-
 tests/ui/parser/issues/issue-17718-const-mut.stderr           | 2 +-
 tests/ui/parser/issues/issue-17904-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-17904.stderr                     | 2 +-
 tests/ui/parser/issues/issue-1802-1.stderr                    | 2 +-
 tests/ui/parser/issues/issue-1802-2.stderr                    | 2 +-
 tests/ui/parser/issues/issue-19398.stderr                     | 2 +-
 tests/ui/parser/issues/issue-20616-1.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-3.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-4.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-5.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-6.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-7.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-8.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20616-9.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20711-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-20711.stderr                     | 2 +-
 tests/ui/parser/issues/issue-21146.stderr                     | 2 +-
 tests/ui/parser/issues/issue-21153.stderr                     | 2 +-
 tests/ui/parser/issues/issue-22647.stderr                     | 2 +-
 tests/ui/parser/issues/issue-22712.stderr                     | 2 +-
 tests/ui/parser/issues/issue-2354-1.stderr                    | 2 +-
 tests/ui/parser/issues/issue-2354.stderr                      | 2 +-
 tests/ui/parser/issues/issue-24197.stderr                     | 2 +-
 tests/ui/parser/issues/issue-24375.stderr                     | 2 +-
 tests/ui/parser/issues/issue-24780.stderr                     | 2 +-
 tests/ui/parser/issues/issue-3036.stderr                      | 2 +-
 tests/ui/parser/issues/issue-31804.stderr                     | 2 +-
 tests/ui/parser/issues/issue-32214.stderr                     | 2 +-
 tests/ui/parser/issues/issue-32446.stderr                     | 2 +-
 tests/ui/parser/issues/issue-32501.stderr                     | 2 +-
 tests/ui/parser/issues/issue-33262.stderr                     | 2 +-
 tests/ui/parser/issues/issue-33455.stderr                     | 2 +-
 tests/ui/parser/issues/issue-34222-1.stderr                   | 2 +-
 tests/ui/parser/issues/issue-34255-1.stderr                   | 2 +-
 tests/ui/parser/issues/issue-39616.stderr                     | 2 +-
 tests/ui/parser/issues/issue-43692.stderr                     | 2 +-
 tests/ui/parser/issues/issue-44021.stderr                     | 2 +-
 tests/ui/parser/issues/issue-44406.stderr                     | 2 +-
 tests/ui/parser/issues/issue-45296.stderr                     | 2 +-
 tests/ui/parser/issues/issue-46186.stderr                     | 2 +-
 tests/ui/parser/issues/issue-48636.stderr                     | 2 +-
 tests/ui/parser/issues/issue-51602.stderr                     | 2 +-
 tests/ui/parser/issues/issue-5544-a.stderr                    | 2 +-
 tests/ui/parser/issues/issue-5544-b.stderr                    | 2 +-
 tests/ui/parser/issues/issue-56031.stderr                     | 2 +-
 tests/ui/parser/issues/issue-57198.stderr                     | 2 +-
 tests/ui/parser/issues/issue-5806.stderr                      | 2 +-
 .../parser/issues/issue-58094-missing-right-square-bracket.rs | 2 +-
 .../issues/issue-58094-missing-right-square-bracket.stderr    | 2 +-
 tests/ui/parser/issues/issue-58856-1.stderr                   | 2 +-
 tests/ui/parser/issues/issue-58856-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-60075.stderr                     | 2 +-
 tests/ui/parser/issues/issue-61858.stderr                     | 2 +-
 tests/ui/parser/issues/issue-62524.rs                         | 2 +-
 tests/ui/parser/issues/issue-62524.stderr                     | 2 +-
 tests/ui/parser/issues/issue-62546.stderr                     | 2 +-
 tests/ui/parser/issues/issue-62554.stderr                     | 2 +-
 tests/ui/parser/issues/issue-62660.stderr                     | 2 +-
 tests/ui/parser/issues/issue-62881.stderr                     | 2 +-
 tests/ui/parser/issues/issue-62894.stderr                     | 2 +-
 tests/ui/parser/issues/issue-63135.rs                         | 2 +-
 tests/ui/parser/issues/issue-63135.stderr                     | 2 +-
 tests/ui/parser/issues/issue-6610.stderr                      | 2 +-
 .../parser/issues/issue-66357-unexpected-unreachable.stderr   | 2 +-
 .../parser/issues/issue-68091-unicode-ident-after-if.stderr   | 2 +-
 .../issue-68092-unicode-ident-after-incomplete-expr.stderr    | 2 +-
 tests/ui/parser/issues/issue-68987-unmatch-issue-1.stderr     | 2 +-
 tests/ui/parser/issues/issue-68987-unmatch-issue.stderr       | 2 +-
 tests/ui/parser/issues/issue-69259.stderr                     | 2 +-
 .../issues/issue-70552-ascription-in-parens-after-call.stderr | 2 +-
 tests/ui/parser/issues/issue-70583-block-is-empty-1.stderr    | 2 +-
 tests/ui/parser/issues/issue-70583-block-is-empty-2.stderr    | 2 +-
 tests/ui/parser/issues/issue-72253.stderr                     | 2 +-
 tests/ui/parser/issues/issue-72373.stderr                     | 2 +-
 tests/ui/parser/issues/issue-76437-async.stderr               | 2 +-
 tests/ui/parser/issues/issue-76437-const-async-unsafe.stderr  | 2 +-
 tests/ui/parser/issues/issue-76437-const-async.stderr         | 2 +-
 tests/ui/parser/issues/issue-76437-const.stderr               | 2 +-
 tests/ui/parser/issues/issue-76437-pub-crate-unsafe.stderr    | 2 +-
 tests/ui/parser/issues/issue-76437-unsafe.stderr              | 2 +-
 tests/ui/parser/issues/issue-76597.stderr                     | 2 +-
 tests/ui/parser/issues/issue-7970b.stderr                     | 2 +-
 tests/ui/parser/issues/issue-81806.stderr                     | 2 +-
 tests/ui/parser/issues/issue-83639.stderr                     | 2 +-
 tests/ui/parser/issues/issue-84104.stderr                     | 2 +-
 tests/ui/parser/issues/issue-84148-2.stderr                   | 2 +-
 tests/ui/parser/issues/issue-8537.stderr                      | 2 +-
 tests/ui/parser/issues/issue-86895.stderr                     | 2 +-
 .../issues/issue-87217-keyword-order/wrong-async.stderr       | 2 +-
 .../issues/issue-87217-keyword-order/wrong-const.stderr       | 2 +-
 .../issues/issue-87217-keyword-order/wrong-unsafe.stderr      | 2 +-
 tests/ui/parser/issues/issue-87694-duplicated-pub.stderr      | 2 +-
 tests/ui/parser/issues/issue-87694-misplaced-pub.stderr       | 2 +-
 tests/ui/parser/issues/issue-87812-path.stderr                | 2 +-
 tests/ui/parser/issues/issue-87812.stderr                     | 2 +-
 tests/ui/parser/issues/issue-88770.stderr                     | 2 +-
 tests/ui/parser/issues/issue-88818.stderr                     | 2 +-
 tests/ui/parser/issues/issue-89388.stderr                     | 2 +-
 tests/ui/parser/issues/issue-89574.stderr                     | 2 +-
 .../issue-89971-outer-attr-following-inner-attr-ice.stderr    | 2 +-
 tests/ui/parser/issues/issue-91421.stderr                     | 2 +-
 tests/ui/parser/issues/issue-93867.stderr                     | 2 +-
 tests/ui/parser/issues/issue-98601-delimiter-error-1.stderr   | 2 +-
 .../issue-98601-delimiter-error-unexpected-close.stderr       | 2 +-
 .../issues/issue-99625-enum-struct-mutually-exclusive.stderr  | 2 +-
 tests/ui/parser/keyword-abstract.stderr                       | 2 +-
 tests/ui/parser/keyword-as-as-identifier.stderr               | 2 +-
 tests/ui/parser/keyword-break-as-identifier.stderr            | 2 +-
 tests/ui/parser/keyword-const-as-identifier.stderr            | 2 +-
 tests/ui/parser/keyword-continue-as-identifier.stderr         | 2 +-
 tests/ui/parser/keyword-else-as-identifier.stderr             | 2 +-
 tests/ui/parser/keyword-enum-as-identifier.stderr             | 2 +-
 tests/ui/parser/keyword-final.stderr                          | 2 +-
 tests/ui/parser/keyword-fn-as-identifier.stderr               | 2 +-
 tests/ui/parser/keyword-for-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-if-as-identifier.stderr               | 2 +-
 tests/ui/parser/keyword-impl-as-identifier.stderr             | 2 +-
 tests/ui/parser/keyword-in-as-identifier.stderr               | 2 +-
 tests/ui/parser/keyword-let-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-loop-as-identifier.stderr             | 2 +-
 tests/ui/parser/keyword-match-as-identifier.stderr            | 2 +-
 tests/ui/parser/keyword-mod-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-move-as-identifier.stderr             | 2 +-
 tests/ui/parser/keyword-mut-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-override.stderr                       | 2 +-
 tests/ui/parser/keyword-pub-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-ref-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-return-as-identifier.stderr           | 2 +-
 tests/ui/parser/keyword-static-as-identifier.stderr           | 2 +-
 tests/ui/parser/keyword-struct-as-identifier.stderr           | 2 +-
 tests/ui/parser/keyword-trait-as-identifier.stderr            | 2 +-
 tests/ui/parser/keyword-try-as-identifier-edition2018.stderr  | 2 +-
 tests/ui/parser/keyword-type-as-identifier.stderr             | 2 +-
 tests/ui/parser/keyword-typeof.stderr                         | 2 +-
 tests/ui/parser/keyword-unsafe-as-identifier.stderr           | 2 +-
 tests/ui/parser/keyword-use-as-identifier.stderr              | 2 +-
 tests/ui/parser/keyword-where-as-identifier.stderr            | 2 +-
 tests/ui/parser/keyword-while-as-identifier.stderr            | 2 +-
 tests/ui/parser/keyword.stderr                                | 2 +-
 tests/ui/parser/lifetime-semicolon.stderr                     | 2 +-
 tests/ui/parser/lit-err-in-macro.stderr                       | 2 +-
 tests/ui/parser/macro-bad-delimiter-ident.stderr              | 2 +-
 tests/ui/parser/macro-keyword.stderr                          | 2 +-
 tests/ui/parser/macro-mismatched-delim-brace-paren.stderr     | 2 +-
 tests/ui/parser/macro/bad-macro-argument.stderr               | 2 +-
 tests/ui/parser/macro/issue-37113.stderr                      | 2 +-
 tests/ui/parser/macro/issue-37234.stderr                      | 2 +-
 tests/ui/parser/macro/macro-doc-comments-1.stderr             | 2 +-
 tests/ui/parser/macro/macro-doc-comments-2.stderr             | 2 +-
 tests/ui/parser/macro/macro-expand-to-match-arm.stderr        | 2 +-
 tests/ui/parser/match-arrows-block-then-binop.stderr          | 2 +-
 tests/ui/parser/match-refactor-to-expr.stderr                 | 2 +-
 tests/ui/parser/mbe_missing_right_paren.stderr                | 2 +-
 .../method-call-on-struct-literal-in-if-condition.stderr      | 2 +-
 .../missing-close-brace-in-impl-trait.stderr                  | 2 +-
 .../mismatched-braces/missing-close-brace-in-struct.stderr    | 2 +-
 .../mismatched-braces/missing-close-brace-in-trait.stderr     | 2 +-
 tests/ui/parser/mismatched-delim-brace-empty-block.stderr     | 2 +-
 .../missing-closing-angle-bracket-struct-field-ty.stderr      | 2 +-
 tests/ui/parser/missing-expression-in-for-loop.stderr         | 2 +-
 tests/ui/parser/missing-semicolon.stderr                      | 2 +-
 tests/ui/parser/missing_right_paren.rs                        | 2 +-
 tests/ui/parser/missing_right_paren.stderr                    | 2 +-
 tests/ui/parser/misspelled-macro-rules.stderr                 | 2 +-
 tests/ui/parser/mod_file_with_path_attr.stderr                | 2 +-
 tests/ui/parser/multiline-comment-line-tracking.stderr        | 2 +-
 tests/ui/parser/multitrait.stderr                             | 2 +-
 tests/ui/parser/nested-bad-turbofish.stderr                   | 2 +-
 tests/ui/parser/nested-missing-closing-angle-bracket.stderr   | 2 +-
 tests/ui/parser/new-unicode-escapes-1.stderr                  | 2 +-
 tests/ui/parser/new-unicode-escapes-2.stderr                  | 2 +-
 tests/ui/parser/new-unicode-escapes-4.stderr                  | 2 +-
 tests/ui/parser/obsolete-syntax-impl-for-dotdot.stderr        | 2 +-
 tests/ui/parser/omitted-arg-in-item-fn.stderr                 | 2 +-
 tests/ui/parser/paamayim-nekudotayim.stderr                   | 2 +-
 tests/ui/parser/parser-recovery-1.stderr                      | 2 +-
 tests/ui/parser/parser-recovery-2.stderr                      | 2 +-
 tests/ui/parser/pat-lt-bracket-1.stderr                       | 2 +-
 tests/ui/parser/pat-lt-bracket-2.stderr                       | 2 +-
 tests/ui/parser/pat-lt-bracket-3.stderr                       | 2 +-
 tests/ui/parser/pat-lt-bracket-4.stderr                       | 2 +-
 tests/ui/parser/pat-lt-bracket-5.stderr                       | 2 +-
 tests/ui/parser/pat-ranges-1.stderr                           | 2 +-
 tests/ui/parser/pat-ranges-2.stderr                           | 2 +-
 tests/ui/parser/pat-ranges-3.stderr                           | 2 +-
 tests/ui/parser/pat-ranges-4.stderr                           | 2 +-
 tests/ui/parser/pat-ref-enum.stderr                           | 2 +-
 tests/ui/parser/pat-tuple-1.stderr                            | 2 +-
 tests/ui/parser/pat-tuple-3.stderr                            | 2 +-
 tests/ui/parser/pub-method-macro.stderr                       | 2 +-
 tests/ui/parser/public-instead-of-pub-1.stderr                | 2 +-
 tests/ui/parser/public-instead-of-pub-2.stderr                | 2 +-
 tests/ui/parser/public-instead-of-pub-3.stderr                | 2 +-
 tests/ui/parser/public-instead-of-pub.stderr                  | 2 +-
 tests/ui/parser/qualified-path-in-turbofish.stderr            | 2 +-
 tests/ui/parser/range-3.stderr                                | 2 +-
 tests/ui/parser/range-4.stderr                                | 2 +-
 tests/ui/parser/range-inclusive-extra-equals.stderr           | 2 +-
 tests/ui/parser/range_inclusive.stderr                        | 2 +-
 .../issue-70677-panic-on-unterminated-raw-str-at-eof.stderr   | 2 +-
 tests/ui/parser/raw/raw-byte-string-eof.stderr                | 2 +-
 tests/ui/parser/raw/raw-literal-self.stderr                   | 2 +-
 tests/ui/parser/raw/raw-literal-underscore.stderr             | 2 +-
 tests/ui/parser/raw/raw-str-delim.stderr                      | 2 +-
 tests/ui/parser/raw/raw-str-unterminated.stderr               | 2 +-
 tests/ui/parser/raw/raw-string-2.stderr                       | 2 +-
 tests/ui/parser/raw/raw-string.stderr                         | 2 +-
 tests/ui/parser/raw/too-many-hash.stderr                      | 2 +-
 tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr  | 2 +-
 .../parser/recover/recover-assoc-lifetime-constraint.stderr   | 2 +-
 ...r-field-extra-angle-brackets-in-struct-with-a-field.stderr | 2 +-
 .../parser/recover/recover-field-extra-angle-brackets.stderr  | 2 +-
 tests/ui/parser/recover/recover-struct.stderr                 | 2 +-
 tests/ui/parser/recover/recover-tuple-pat.stderr              | 2 +-
 tests/ui/parser/recovered-struct-variant.stderr               | 2 +-
 tests/ui/parser/regions-out-of-scope-slice.stderr             | 2 +-
 tests/ui/parser/removed-syntax-closure-lifetime.stderr        | 2 +-
 tests/ui/parser/removed-syntax-enum-newtype.stderr            | 2 +-
 tests/ui/parser/removed-syntax-field-let.stderr               | 2 +-
 tests/ui/parser/removed-syntax-field-semicolon.stderr         | 2 +-
 tests/ui/parser/removed-syntax-fixed-vec.stderr               | 2 +-
 tests/ui/parser/removed-syntax-mode.stderr                    | 2 +-
 tests/ui/parser/removed-syntax-mut-vec-expr.stderr            | 2 +-
 tests/ui/parser/removed-syntax-mut-vec-ty.stderr              | 2 +-
 tests/ui/parser/removed-syntax-ptr-lifetime.stderr            | 2 +-
 tests/ui/parser/removed-syntax-record.stderr                  | 2 +-
 tests/ui/parser/removed-syntax-uniq-mut-expr.stderr           | 2 +-
 tests/ui/parser/removed-syntax-uniq-mut-ty.stderr             | 2 +-
 tests/ui/parser/removed-syntax-with-1.stderr                  | 2 +-
 tests/ui/parser/self-in-function-arg.stderr                   | 2 +-
 tests/ui/parser/shebang/issue-71471-ignore-tidy.stderr        | 2 +-
 tests/ui/parser/shebang/shebang-doc-comment.stderr            | 2 +-
 tests/ui/parser/shebang/shebang-must-start-file.stderr        | 2 +-
 tests/ui/parser/similar-tokens.stderr                         | 2 +-
 tests/ui/parser/struct-filed-with-attr.stderr                 | 2 +-
 tests/ui/parser/struct-literal-in-match-discriminant.stderr   | 2 +-
 tests/ui/parser/suggest-assoc-const.stderr                    | 2 +-
 tests/ui/parser/suggest-const-for-global-var.stderr           | 2 +-
 .../suggest-removing-semicolon-after-impl-trait-items.stderr  | 2 +-
 tests/ui/parser/suggest-semi-in-array.stderr                  | 2 +-
 tests/ui/parser/suggest-semicolon-before-array.stderr         | 2 +-
 tests/ui/parser/suggest_misplaced_generics/enum.stderr        | 2 +-
 .../suggest_misplaced_generics/existing_generics.stderr       | 2 +-
 .../suggest_misplaced_generics/fn-complex-generics.stderr     | 2 +-
 .../suggest_misplaced_generics/fn-invalid-generics.stderr     | 2 +-
 tests/ui/parser/suggest_misplaced_generics/fn-simple.stderr   | 2 +-
 tests/ui/parser/suggest_misplaced_generics/struct.stderr      | 2 +-
 tests/ui/parser/suggest_misplaced_generics/trait.stderr       | 2 +-
 tests/ui/parser/suggest_misplaced_generics/type.stderr        | 2 +-
 tests/ui/parser/trailing-carriage-return-in-string.stderr     | 2 +-
 tests/ui/parser/trailing-question-in-macro-type.stderr        | 2 +-
 tests/ui/parser/trait-bounds-not-on-impl.stderr               | 2 +-
 tests/ui/parser/trait-object-polytrait-priority.stderr        | 2 +-
 tests/ui/parser/trait-pub-assoc-const.stderr                  | 2 +-
 tests/ui/parser/trait-pub-assoc-ty.stderr                     | 2 +-
 tests/ui/parser/trait-pub-method.stderr                       | 2 +-
 tests/ui/parser/unbalanced-doublequote.stderr                 | 2 +-
 tests/ui/parser/unclosed-braces.stderr                        | 2 +-
 tests/ui/parser/unclosed-delimiter-in-dep.stderr              | 2 +-
 tests/ui/parser/unclosed_delim_mod.stderr                     | 2 +-
 tests/ui/parser/unmatched-delimiter-at-end-of-file.stderr     | 2 +-
 tests/ui/parser/unmatched-langle-2.stderr                     | 2 +-
 tests/ui/parser/unsafe-foreign-mod.stderr                     | 2 +-
 tests/ui/parser/unsized.stderr                                | 2 +-
 tests/ui/parser/unsized2.stderr                               | 2 +-
 tests/ui/parser/use-ends-with-mod-sep.stderr                  | 2 +-
 tests/ui/parser/use-unclosed-brace.stderr                     | 2 +-
 tests/ui/parser/virtual-structs.stderr                        | 2 +-
 tests/ui/parser/where-clauses-no-bounds-or-predicates.stderr  | 2 +-
 tests/ui/parser/while-if-let-without-body.stderr              | 2 +-
 .../bind-by-move-no-subbindings-fun-param.stderr              | 2 +-
 .../borrowck-pat-by-move-and-ref-inverse-promotion.stderr     | 2 +-
 tests/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr | 2 +-
 tests/ui/pattern/issue-114896.stderr                          | 2 +-
 tests/ui/pattern/issue-115599.stderr                          | 2 +-
 tests/ui/pattern/issue-52240.stderr                           | 2 +-
 .../ui/pattern/issue-66270-pat-struct-parser-recovery.stderr  | 2 +-
 tests/ui/pattern/issue-72565.stderr                           | 2 +-
 .../ui/pattern/issue-80186-mut-binding-help-suggestion.stderr | 2 +-
 tests/ui/pattern/issue-94866.stderr                           | 2 +-
 tests/ui/pattern/issue-95878.stderr                           | 2 +-
 .../move-ref-patterns-default-binding-modes-fixable.stderr    | 2 +-
 .../move-ref-patterns-default-binding-modes.stderr            | 2 +-
 tests/ui/pattern/pat-shadow-in-nested-binding.stderr          | 2 +-
 tests/ui/pattern/pat-struct-field-expr-has-type.stderr        | 2 +-
 tests/ui/pattern/pat-type-err-formal-param.stderr             | 2 +-
 tests/ui/pattern/pattern-ident-path-generics.stderr           | 2 +-
 tests/ui/pattern/pattern-tyvar-2.stderr                       | 2 +-
 tests/ui/pattern/pattern-tyvar.stderr                         | 2 +-
 tests/ui/pattern/slice-patterns-irrefutable.stderr            | 2 +-
 ...ding-appropriate-missing-pattern-excluding-comments.stderr | 2 +-
 .../pattern/usefulness/const-partial_eq-fallback-ice.stderr   | 2 +-
 tests/ui/pattern/usefulness/guards.stderr                     | 2 +-
 .../usefulness/integer-ranges/pointer-sized-int.allow.stderr  | 2 +-
 .../usefulness/issue-105479-str-non-exhaustiveness.stderr     | 2 +-
 tests/ui/pattern/usefulness/issue-12116.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-12369.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-13727.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-15129.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-2111.stderr                 | 2 +-
 tests/ui/pattern/usefulness/issue-30240-b.stderr              | 2 +-
 tests/ui/pattern/usefulness/issue-3096-1.stderr               | 2 +-
 tests/ui/pattern/usefulness/issue-3096-2.stderr               | 2 +-
 tests/ui/pattern/usefulness/issue-31561.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-3601.stderr                 | 2 +-
 tests/ui/pattern/usefulness/issue-39362.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-40221.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-4321.stderr                 | 2 +-
 tests/ui/pattern/usefulness/issue-50900.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-56379.stderr                | 2 +-
 tests/ui/pattern/usefulness/issue-72377.stderr                | 2 +-
 .../usefulness/issue-78123-non-exhaustive-reference.stderr    | 2 +-
 .../pattern/usefulness/issue-82772-match-box-as-struct.stderr | 2 +-
 tests/ui/pattern/usefulness/match-privately-empty.stderr      | 2 +-
 tests/ui/pattern/usefulness/match-ref-ice.stderr              | 2 +-
 tests/ui/pattern/usefulness/match-slice-patterns.stderr       | 2 +-
 .../ui/pattern/usefulness/nested-non-exhaustive-enums.stderr  | 2 +-
 .../ui/pattern/usefulness/refutable-pattern-in-fn-arg.stderr  | 2 +-
 .../pattern/usefulness/struct-like-enum-nonexhaustive.stderr  | 2 +-
 .../ui/pattern/usefulness/struct-pattern-match-useless.stderr | 2 +-
 tests/ui/pattern/usefulness/tuple-struct-nonexhaustive.stderr | 2 +-
 tests/ui/pattern/usefulness/unstable-gated-patterns.stderr    | 2 +-
 tests/ui/pin-macro/cant_access_internals.stderr               | 2 +-
 .../ui/point-to-type-err-cause-on-impl-trait-return-2.stderr  | 2 +-
 tests/ui/polymorphization/const_parameters/functions.stderr   | 2 +-
 tests/ui/polymorphization/promoted-function-1.stderr          | 2 +-
 tests/ui/polymorphization/promoted-function-2.stderr          | 2 +-
 tests/ui/privacy/decl-macro.stderr                            | 2 +-
 tests/ui/privacy/export-tag-variant.stderr                    | 2 +-
 .../issue-111220-2-tuple-struct-fields-projection.stderr      | 2 +-
 tests/ui/privacy/issue-75062-fieldless-tuple-struct.stderr    | 2 +-
 tests/ui/privacy/issue-75906.stderr                           | 2 +-
 tests/ui/privacy/legacy-ctor-visibility.stderr                | 2 +-
 tests/ui/privacy/privacy-ufcs.stderr                          | 2 +-
 tests/ui/privacy/privacy4.stderr                              | 2 +-
 tests/ui/privacy/private-field-ty-err.stderr                  | 2 +-
 tests/ui/privacy/private-impl-method.stderr                   | 2 +-
 tests/ui/privacy/private-in-public-non-principal-2.stderr     | 2 +-
 tests/ui/privacy/private-in-public-non-principal.stderr       | 2 +-
 tests/ui/privacy/private-item-simple.stderr                   | 2 +-
 tests/ui/privacy/private-method-cross-crate.stderr            | 2 +-
 tests/ui/privacy/private-method-inherited.stderr              | 2 +-
 tests/ui/privacy/private-method.stderr                        | 2 +-
 tests/ui/privacy/private-struct-field-cross-crate.stderr      | 2 +-
 tests/ui/privacy/private-struct-field-ctor.stderr             | 2 +-
 tests/ui/privacy/private-struct-field-pattern.stderr          | 2 +-
 tests/ui/privacy/private-struct-field.stderr                  | 2 +-
 tests/ui/privacy/restricted/struct-literal-field.stderr       | 2 +-
 tests/ui/privacy/sealed-traits/private-trait-non-local.stderr | 2 +-
 tests/ui/privacy/sealed-traits/private-trait.stderr           | 2 +-
 tests/ui/privacy/sealed-traits/re-exported-trait.stderr       | 2 +-
 tests/ui/privacy/union-field-privacy-2.stderr                 | 2 +-
 tests/ui/privacy/where-priv-type.stderr                       | 2 +-
 tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr       | 2 +-
 tests/ui/proc-macro/cfg-eval-fail.stderr                      | 2 +-
 tests/ui/proc-macro/define-two.stderr                         | 2 +-
 tests/ui/proc-macro/derive-helper-legacy-limits.stderr        | 2 +-
 tests/ui/proc-macro/derive-still-gated.stderr                 | 2 +-
 .../edition-gated-async-move-syntax-issue89699.stderr         | 2 +-
 tests/ui/proc-macro/expand-to-unstable.stderr                 | 2 +-
 tests/ui/proc-macro/export-macro.stderr                       | 2 +-
 .../ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr  | 2 +-
 tests/ui/proc-macro/import.stderr                             | 2 +-
 tests/ui/proc-macro/invalid-punct-ident-1.stderr              | 2 +-
 tests/ui/proc-macro/invalid-punct-ident-2.stderr              | 2 +-
 tests/ui/proc-macro/invalid-punct-ident-3.stderr              | 2 +-
 tests/ui/proc-macro/issue-107113-wrap.stderr                  | 2 +-
 tests/ui/proc-macro/issue-37788.stderr                        | 2 +-
 tests/ui/proc-macro/issue-38586.stderr                        | 2 +-
 tests/ui/proc-macro/issue-50493.stderr                        | 2 +-
 tests/ui/proc-macro/issue-59191-replace-root-with-fn.stderr   | 2 +-
 tests/ui/proc-macro/issue-66286.stderr                        | 2 +-
 tests/ui/proc-macro/issue-75801.stderr                        | 2 +-
 tests/ui/proc-macro/issue-76270-panic-in-libproc-macro.stderr | 2 +-
 tests/ui/proc-macro/issue-79148.stderr                        | 2 +-
 tests/ui/proc-macro/issue-81543-item-parse-err.stderr         | 2 +-
 .../proc-macro/issue-83469-global-alloc-invalid-stmt.stderr   | 2 +-
 tests/ui/proc-macro/issue-86781-bad-inner-doc.stderr          | 2 +-
 tests/ui/proc-macro/item-error.stderr                         | 2 +-
 tests/ui/proc-macro/lifetimes.stderr                          | 2 +-
 tests/ui/proc-macro/lints_in_proc_macros.stderr               | 2 +-
 tests/ui/proc-macro/load-panic-backtrace.stderr               | 2 +-
 tests/ui/proc-macro/load-panic.stderr                         | 2 +-
 tests/ui/proc-macro/macro-brackets.stderr                     | 2 +-
 tests/ui/proc-macro/macro-rules-derive.stderr                 | 2 +-
 tests/ui/proc-macro/macros-in-extern-derive.stderr            | 2 +-
 tests/ui/proc-macro/no-macro-use-attr.stderr                  | 2 +-
 tests/ui/proc-macro/non-root.stderr                           | 2 +-
 tests/ui/proc-macro/raw-ident.stderr                          | 2 +-
 tests/ui/proc-macro/shadow.stderr                             | 2 +-
 tests/ui/proc-macro/signature.stderr                          | 2 +-
 tests/ui/proc-macro/test-same-crate.stderr                    | 2 +-
 tests/ui/proc-macro/two-crate-types-1.stderr                  | 2 +-
 tests/ui/proc-macro/two-crate-types-2.stderr                  | 2 +-
 tests/ui/pub/pub-ident-fn-2.stderr                            | 2 +-
 tests/ui/pub/pub-ident-fn-or-struct.stderr                    | 2 +-
 tests/ui/pub/pub-ident-fn-with-lifetime-2.stderr              | 2 +-
 tests/ui/pub/pub-ident-fn-with-lifetime.stderr                | 2 +-
 tests/ui/pub/pub-ident-fn.stderr                              | 2 +-
 tests/ui/pub/pub-ident-struct-2.stderr                        | 2 +-
 tests/ui/pub/pub-ident-struct-3.stderr                        | 2 +-
 tests/ui/pub/pub-ident-struct-4.stderr                        | 2 +-
 tests/ui/pub/pub-ident-struct-with-lifetime.stderr            | 2 +-
 tests/ui/pub/pub-ident-struct.stderr                          | 2 +-
 tests/ui/pub/pub-ident-with-lifetime-incomplete.stderr        | 2 +-
 tests/ui/pub/pub-restricted-error.stderr                      | 2 +-
 tests/ui/pub/pub-restricted-non-path.stderr                   | 2 +-
 tests/ui/qualified/qualified-path-params-2.stderr             | 2 +-
 tests/ui/query-system/fn-sig-cycle-arity.stderr               | 2 +-
 .../no-query-in-printing-during-query-descr.stderr            | 2 +-
 tests/ui/query-system/query_depth.stderr                      | 2 +-
 tests/ui/range/range-inclusive-pattern-precedence.stderr      | 2 +-
 tests/ui/range/range-inclusive-pattern-precedence2.stderr     | 2 +-
 tests/ui/range/range_traits-2.stderr                          | 2 +-
 tests/ui/range/range_traits-3.stderr                          | 2 +-
 tests/ui/range/range_traits-6.stderr                          | 2 +-
 tests/ui/reachable/expr_add.stderr                            | 2 +-
 tests/ui/reachable/expr_again.stderr                          | 2 +-
 tests/ui/reachable/expr_repeat.stderr                         | 2 +-
 tests/ui/reachable/expr_return.stderr                         | 2 +-
 tests/ui/reachable/expr_return_in_macro.stderr                | 2 +-
 tests/ui/reachable/expr_type.stderr                           | 2 +-
 tests/ui/reachable/unreachable-arm.stderr                     | 2 +-
 tests/ui/reachable/unreachable-code-ret.stderr                | 2 +-
 tests/ui/reachable/unreachable-code.stderr                    | 2 +-
 tests/ui/reachable/unreachable-loop-patterns.stderr           | 2 +-
 tests/ui/reachable/unreachable-variant.stderr                 | 2 +-
 tests/ui/recursion/issue-26548-recursion-via-normalize.stderr | 2 +-
 .../recursion/issue-38591-non-regular-dropck-recursion.stderr | 2 +-
 tests/ui/recursion/issue-83150.stderr                         | 2 +-
 tests/ui/recursion/recursion.stderr                           | 2 +-
 tests/ui/recursion/recursive-enum.stderr                      | 2 +-
 tests/ui/recursion/recursive-reexports.stderr                 | 2 +-
 tests/ui/recursion/recursive-static-definition.stderr         | 2 +-
 tests/ui/recursion/recursive-types-are-not-uninhabited.stderr | 2 +-
 tests/ui/recursion_limit/invalid_digit_type.stderr            | 2 +-
 tests/ui/recursion_limit/invalid_macro.stderr                 | 2 +-
 tests/ui/recursion_limit/issue-105700.stderr                  | 2 +-
 tests/ui/recursion_limit/no-value.stderr                      | 2 +-
 tests/ui/recursion_limit/zero-overflow.stderr                 | 2 +-
 tests/ui/recursion_limit/zero.stderr                          | 2 +-
 .../regions/do-not-suggest-adding-bound-to-opaque-type.stderr | 2 +-
 tests/ui/regions/forall-wf-ref-reflexive.stderr               | 2 +-
 tests/ui/regions/issue-101280.stderr                          | 2 +-
 tests/ui/regions/issue-102374.stderr                          | 2 +-
 tests/ui/regions/issue-102392.stderr                          | 2 +-
 tests/ui/regions/issue-12470.stderr                           | 2 +-
 tests/ui/regions/issue-28848.stderr                           | 2 +-
 tests/ui/regions/issue-78262.base.stderr                      | 2 +-
 tests/ui/regions/issue-78262.polonius.stderr                  | 2 +-
 tests/ui/regions/outlives-with-missing.stderr                 | 2 +-
 tests/ui/regions/region-bound-on-closure-outlives-call.stderr | 2 +-
 .../ui/regions/region-invariant-static-error-reporting.stderr | 2 +-
 .../regions/region-lifetime-bounds-on-fns-where-clause.stderr | 2 +-
 ...region-multiple-lifetime-bounds-on-fns-where-clause.stderr | 2 +-
 tests/ui/regions/region-object-lifetime-2.stderr              | 2 +-
 tests/ui/regions/region-object-lifetime-4.stderr              | 2 +-
 tests/ui/regions/region-object-lifetime-5.stderr              | 2 +-
 tests/ui/regions/regions-addr-of-self.stderr                  | 2 +-
 ...regions-assoc-type-in-supertrait-outlives-container.stderr | 2 +-
 .../regions-assoc-type-static-bound-in-trait-not-met.stderr   | 2 +-
 .../regions-bounded-method-type-parameters-cross-crate.stderr | 2 +-
 .../regions-bounded-method-type-parameters-trait-bound.stderr | 2 +-
 .../ui/regions/regions-bounded-method-type-parameters.stderr  | 2 +-
 tests/ui/regions/regions-close-object-into-object-1.stderr    | 2 +-
 tests/ui/regions/regions-close-object-into-object-3.stderr    | 2 +-
 .../regions/regions-close-over-type-parameter-multiple.stderr | 2 +-
 tests/ui/regions/regions-creating-enums3.stderr               | 2 +-
 tests/ui/regions/regions-creating-enums4.stderr               | 2 +-
 tests/ui/regions/regions-early-bound-error-method.stderr      | 2 +-
 tests/ui/regions/regions-early-bound-error.stderr             | 2 +-
 tests/ui/regions/regions-escape-method.stderr                 | 2 +-
 tests/ui/regions/regions-escape-via-trait-or-not.stderr       | 2 +-
 .../ui/regions/regions-fn-subtyping-return-static-fail.stderr | 2 +-
 tests/ui/regions/regions-free-region-ordering-callee-4.stderr | 2 +-
 .../ui/regions/regions-free-region-ordering-incorrect.stderr  | 2 +-
 tests/ui/regions/regions-glb-free-free.stderr                 | 2 +-
 .../ui/regions/regions-implied-bounds-projection-gap-1.stderr | 2 +-
 .../regions/regions-implied-bounds-projection-gap-hr-1.stderr | 2 +-
 tests/ui/regions/regions-in-enums-anon.stderr                 | 2 +-
 tests/ui/regions/regions-in-structs-anon.stderr               | 2 +-
 tests/ui/regions/regions-infer-at-fn-not-param.stderr         | 2 +-
 tests/ui/regions/regions-infer-borrow-scope-too-big.stderr    | 2 +-
 tests/ui/regions/regions-infer-bound-from-trait-self.stderr   | 2 +-
 tests/ui/regions/regions-infer-call-3.stderr                  | 2 +-
 .../regions/regions-infer-contravariance-due-to-decl.stderr   | 2 +-
 tests/ui/regions/regions-infer-covariance-due-to-decl.stderr  | 2 +-
 tests/ui/regions/regions-infer-invariance-due-to-decl.stderr  | 2 +-
 .../regions-infer-invariance-due-to-mutability-3.stderr       | 2 +-
 .../regions-infer-invariance-due-to-mutability-4.stderr       | 2 +-
 tests/ui/regions/regions-infer-paramd-indirect.stderr         | 2 +-
 tests/ui/regions/regions-infer-proc-static-upvar.stderr       | 2 +-
 tests/ui/regions/regions-lifetime-bounds-on-fns.stderr        | 2 +-
 tests/ui/regions/regions-name-duplicated.stderr               | 2 +-
 tests/ui/regions/regions-name-static.stderr                   | 2 +-
 tests/ui/regions/regions-nested-fns-2.stderr                  | 2 +-
 .../ui/regions/regions-normalize-in-where-clause-list.stderr  | 2 +-
 .../regions/regions-outlives-projection-container-wc.stderr   | 2 +-
 tests/ui/regions/regions-pattern-typing-issue-19552.stderr    | 2 +-
 tests/ui/regions/regions-pattern-typing-issue-19997.stderr    | 2 +-
 tests/ui/regions/regions-proc-bound-capture.stderr            | 2 +-
 .../regions-reborrow-from-shorter-mut-ref-mut-ref.stderr      | 2 +-
 tests/ui/regions/regions-reborrow-from-shorter-mut-ref.stderr | 2 +-
 tests/ui/regions/regions-ret-borrowed-1.stderr                | 2 +-
 tests/ui/regions/regions-ret-borrowed.stderr                  | 2 +-
 tests/ui/regions/regions-ret.stderr                           | 2 +-
 .../ui/regions/regions-return-ref-to-upvar-issue-17403.stderr | 2 +-
 tests/ui/regions/regions-return-stack-allocated-vec.stderr    | 2 +-
 tests/ui/regions/regions-steal-closure.stderr                 | 2 +-
 tests/ui/regions/regions-trait-variance.stderr                | 2 +-
 tests/ui/regions/regions-var-type-out-of-scope.stderr         | 2 +-
 ...ance-contravariant-use-covariant-in-second-position.stderr | 2 +-
 .../regions-variance-contravariant-use-covariant.stderr       | 2 +-
 .../regions-variance-covariant-use-contravariant.stderr       | 2 +-
 .../regions-variance-invariant-use-contravariant.stderr       | 2 +-
 .../regions/regions-variance-invariant-use-covariant.stderr   | 2 +-
 tests/ui/regions/regions-wf-trait-object.stderr               | 2 +-
 tests/ui/repeat-expr/repeat-to-run-dtor-twice.stderr          | 2 +-
 tests/ui/repr/repr-disallow-on-variant.stderr                 | 2 +-
 tests/ui/repr/transparent-enum-too-many-variants.stderr       | 2 +-
 tests/ui/reserved/reserved-become.stderr                      | 2 +-
 tests/ui/resolve/bad-type-env-capture.stderr                  | 2 +-
 tests/ui/resolve/crate-called-as-function.stderr              | 2 +-
 tests/ui/resolve/crate-in-paths.stderr                        | 2 +-
 tests/ui/resolve/disambiguate-identical-names.stderr          | 2 +-
 tests/ui/resolve/enums-pats-not-idents.stderr                 | 2 +-
 tests/ui/resolve/explicit-self-lowercase-param.stderr         | 2 +-
 tests/ui/resolve/export-fully-qualified-2018.stderr           | 2 +-
 tests/ui/resolve/export-fully-qualified.stderr                | 2 +-
 tests/ui/resolve/fn-new-doesnt-exist.stderr                   | 2 +-
 tests/ui/resolve/impl-items-vis-unresolved.stderr             | 2 +-
 tests/ui/resolve/issue-101749-2.stderr                        | 2 +-
 tests/ui/resolve/issue-101749.stderr                          | 2 +-
 tests/ui/resolve/issue-10200.stderr                           | 2 +-
 tests/ui/resolve/issue-103202.stderr                          | 2 +-
 tests/ui/resolve/issue-105069.stderr                          | 2 +-
 tests/ui/resolve/issue-108529.stderr                          | 2 +-
 tests/ui/resolve/issue-109153.stderr                          | 2 +-
 tests/ui/resolve/issue-109250.stderr                          | 2 +-
 tests/ui/resolve/issue-111312.stderr                          | 2 +-
 tests/ui/resolve/issue-111727.stderr                          | 2 +-
 tests/ui/resolve/issue-116164.stderr                          | 2 +-
 tests/ui/resolve/issue-12796.stderr                           | 2 +-
 tests/ui/resolve/issue-16058.stderr                           | 2 +-
 tests/ui/resolve/issue-17518.stderr                           | 2 +-
 tests/ui/resolve/issue-18252.stderr                           | 2 +-
 tests/ui/resolve/issue-21221-2.stderr                         | 2 +-
 tests/ui/resolve/issue-21221-3.stderr                         | 2 +-
 tests/ui/resolve/issue-21221-4.stderr                         | 2 +-
 tests/ui/resolve/issue-2330.stderr                            | 2 +-
 tests/ui/resolve/issue-23305.stderr                           | 2 +-
 tests/ui/resolve/issue-26545.stderr                           | 2 +-
 tests/ui/resolve/issue-3021.stderr                            | 2 +-
 tests/ui/resolve/issue-30535.stderr                           | 2 +-
 tests/ui/resolve/issue-3099-a.stderr                          | 2 +-
 tests/ui/resolve/issue-3099-b.stderr                          | 2 +-
 tests/ui/resolve/issue-31845.stderr                           | 2 +-
 tests/ui/resolve/issue-33876.stderr                           | 2 +-
 tests/ui/resolve/issue-3907-2.stderr                          | 2 +-
 tests/ui/resolve/issue-3907.stderr                            | 2 +-
 tests/ui/resolve/issue-39226.stderr                           | 2 +-
 tests/ui/resolve/issue-39559.stderr                           | 2 +-
 tests/ui/resolve/issue-5035-2.stderr                          | 2 +-
 tests/ui/resolve/issue-50599.stderr                           | 2 +-
 .../resolve/issue-65025-extern-static-parent-generics.stderr  | 2 +-
 tests/ui/resolve/issue-6642.stderr                            | 2 +-
 tests/ui/resolve/issue-6702.stderr                            | 2 +-
 tests/ui/resolve/issue-69401-trait-fn-no-body-ty-local.stderr | 2 +-
 tests/ui/resolve/issue-80079.stderr                           | 2 +-
 tests/ui/resolve/issue-82156.stderr                           | 2 +-
 tests/ui/resolve/issue-90113.stderr                           | 2 +-
 tests/ui/resolve/missing-in-namespace.stderr                  | 2 +-
 tests/ui/resolve/name-clash-nullary.stderr                    | 2 +-
 .../point-at-type-parameter-shadowing-another-type.stderr     | 2 +-
 tests/ui/resolve/raw-ident-in-path.stderr                     | 2 +-
 tests/ui/resolve/resolve-bad-import-prefix.stderr             | 2 +-
 .../resolve-conflict-extern-crate-vs-extern-crate.stderr      | 2 +-
 .../ui/resolve/resolve-conflict-import-vs-extern-crate.stderr | 2 +-
 tests/ui/resolve/resolve-conflict-import-vs-import.stderr     | 2 +-
 tests/ui/resolve/resolve-conflict-item-vs-extern-crate.stderr | 2 +-
 tests/ui/resolve/resolve-conflict-item-vs-import.stderr       | 2 +-
 tests/ui/resolve/resolve-conflict-type-vs-import.stderr       | 2 +-
 tests/ui/resolve/resolve-label.stderr                         | 2 +-
 .../ui/resolve/suggest-import-without-clobbering-attrs.stderr | 2 +-
 tests/ui/resolve/token-error-correct-2.stderr                 | 2 +-
 tests/ui/resolve/token-error-correct-3.stderr                 | 2 +-
 tests/ui/resolve/token-error-correct-4.stderr                 | 2 +-
 tests/ui/resolve/token-error-correct.stderr                   | 2 +-
 tests/ui/resolve/tool-import.stderr                           | 2 +-
 tests/ui/resolve/unresolved-segments-visibility.stderr        | 2 +-
 tests/ui/resolve/unresolved_static_type_field.stderr          | 2 +-
 tests/ui/resolve/use-self-in-inner-fn.stderr                  | 2 +-
 tests/ui/ret-non-nil.stderr                                   | 2 +-
 tests/ui/return-disjoint-regions.stderr                       | 2 +-
 tests/ui/return/issue-64620.stderr                            | 2 +-
 tests/ui/return/issue-82612-return-mutable-reference.stderr   | 2 +-
 tests/ui/return/return-from-diverging.stderr                  | 2 +-
 tests/ui/return/return-type.stderr                            | 2 +-
 tests/ui/return/return-unit-from-diverging.stderr             | 2 +-
 .../cant-hide-behind-direct-struct-embedded.stderr            | 2 +-
 .../cant-hide-behind-direct-struct-param.stderr               | 2 +-
 .../feature-gate.with_gate.stderr                             | 2 +-
 .../issue-61188-match-slice-forbidden-without-eq.stderr       | 2 +-
 .../match-forbidden-without-eq.stderr                         | 2 +-
 .../match-nonempty-array-forbidden-without-eq.stderr          | 2 +-
 .../match-requires-both-partialeq-and-eq.stderr               | 2 +-
 tests/ui/rfcs/rfc-1717-dllimport/missing-link-attr.stderr     | 2 +-
 tests/ui/rfcs/rfc-1717-dllimport/multiple-renames.stderr      | 2 +-
 tests/ui/rfcs/rfc-1717-dllimport/rename-modifiers.stderr      | 2 +-
 tests/ui/rfcs/rfc-1717-dllimport/rename-to-empty.stderr       | 2 +-
 .../ui/rfcs/rfc-1937-termination-trait/issue-103052-1.stderr  | 2 +-
 .../ui/rfcs/rfc-1937-termination-trait/issue-103052-2.stderr  | 2 +-
 .../termination-trait-impl-trait.stderr                       | 2 +-
 .../termination-trait-in-test-should-panic.stderr             | 2 +-
 .../termination-trait-main-i32.stderr                         | 2 +-
 .../termination-trait-main-wrong-type.stderr                  | 2 +-
 .../termination-trait-not-satisfied.stderr                    | 2 +-
 .../termination-trait-test-wrong-type.stderr                  | 2 +-
 .../rfc-2005-default-binding-mode/borrowck-issue-49631.stderr | 2 +-
 tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr      | 2 +-
 tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr        | 2 +-
 .../rfcs/rfc-2005-default-binding-mode/issue-44912-or.stderr  | 2 +-
 .../rfcs/rfc-2005-default-binding-mode/no-double-error.stderr | 2 +-
 tests/ui/rfcs/rfc-2005-default-binding-mode/slice.stderr      | 2 +-
 .../rfc-2008-non-exhaustive/borrowck-non-exhaustive.stderr    | 2 +-
 tests/ui/rfcs/rfc-2008-non-exhaustive/enum-as-cast.stderr     | 2 +-
 .../omitted-patterns-dont-lint-on-arm.normal.stderr           | 2 +-
 .../rfc-2008-non-exhaustive/stable-omitted-patterns.stderr    | 2 +-
 .../uninhabited/issue-65157-repeated-match-arm.stderr         | 2 +-
 tests/ui/rfcs/rfc-2091-track-caller/error-odd-syntax.stderr   | 2 +-
 tests/ui/rfcs/rfc-2091-track-caller/error-with-main.stderr    | 2 +-
 tests/ui/rfcs/rfc-2091-track-caller/error-with-start.stderr   | 2 +-
 tests/ui/rfcs/rfc-2091-track-caller/only-for-fns.stderr       | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr      | 2 +-
 .../ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr  | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr     | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr    | 2 +-
 .../rfcs/rfc-2093-infer-outlives/explicit-projection.stderr   | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr  | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr   | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr      | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr   | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr   | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr     | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr       | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr        | 2 +-
 .../regions-outlives-nominal-type-region-rev.stderr           | 2 +-
 .../regions-outlives-nominal-type-region.stderr               | 2 +-
 .../regions-outlives-nominal-type-type-rev.stderr             | 2 +-
 .../regions-outlives-nominal-type-type.stderr                 | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr         | 2 +-
 tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr     | 2 +-
 .../rfc-2126-crate-paths/keyword-crate-as-identifier.stderr   | 2 +-
 .../rfcs/rfc-2126-extern-absolute-paths/non-existent-1.stderr | 2 +-
 .../rfcs/rfc-2126-extern-absolute-paths/non-existent-2.stderr | 2 +-
 .../rfcs/rfc-2126-extern-absolute-paths/non-existent-3.stderr | 2 +-
 .../ui/rfcs/rfc-2126-extern-absolute-paths/not-allowed.stderr | 2 +-
 tests/ui/rfcs/rfc-2294-if-let-guard/guard-lifetime-1.stderr   | 2 +-
 tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-1.stderr | 2 +-
 tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-2.stderr | 2 +-
 tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr     | 2 +-
 .../rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr   | 2 +-
 .../rfcs/rfc-2361-dbg-macro/dbg-macro-requires-debug.stderr   | 2 +-
 .../feature-gate-target_feature_11.stderr                     | 2 +-
 tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.mir.stderr    | 2 +-
 tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.thir.stderr   | 2 +-
 .../issue-108645-target-feature-on-main.stderr                | 2 +-
 .../issue-108645-target-feature-on-start.stderr               | 2 +-
 .../feature-gate-do_not_recommend.stderr                      | 2 +-
 .../ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr | 2 +-
 .../crate_name_nonascii_forbidden.stderr                      | 2 +-
 tests/ui/rfcs/rfc-2497-if-let-chains/avoid-invalid-mir.stderr | 2 +-
 .../issue-92010-trait-bound-not-satisfied.stderr              | 2 +-
 .../lifetime-update.stderr                                    | 2 +-
 tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-2018.stderr    | 2 +-
 .../ui/rfcs/rfc-2627-raw-dylib/raw-dylib-windows-only.stderr  | 2 +-
 .../call-const-trait-method-fail.stderr                       | 2 +-
 .../rfc-2632-const-trait-impl/call-generic-in-impl.stderr     | 2 +-
 .../rfc-2632-const-trait-impl/call-generic-method-pass.stderr | 2 +-
 .../const-check-fns-in-const-impl.stderr                      | 2 +-
 .../const-closure-parse-not-item.stderr                       | 2 +-
 .../const-closure-trait-method-fail.stderr                    | 2 +-
 .../const-closure-trait-method.stderr                         | 2 +-
 .../const-default-method-bodies.stderr                        | 2 +-
 .../ui/rfcs/rfc-2632-const-trait-impl/const-drop-bound.stderr | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/const-drop-fail-2.stderr   | 2 +-
 .../rfc-2632-const-trait-impl/const-drop-fail.precise.stderr  | 2 +-
 .../rfc-2632-const-trait-impl/const-drop-fail.stock.stderr    | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr  | 2 +-
 .../ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr | 2 +-
 .../rfc-2632-const-trait-impl/const-impl-norecover.stderr     | 2 +-
 .../const-impl-requires-const-trait.stderr                    | 2 +-
 .../const_derives/derive-const-gate.stderr                    | 2 +-
 .../const_derives/derive-const-non-const-type.stderr          | 2 +-
 .../const_derives/derive-const-with-params.stderr             | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/cross-crate.gatednc.stderr | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/cross-crate.stock.stderr   | 2 +-
 .../default-method-body-is-const-same-trait-ck.stderr         | 2 +-
 .../effects/const_closure-const_trait_impl-ice-113381.stderr  | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/feature-gate.gated.stderr  | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/generic-bound.stderr  | 2 +-
 .../ui/rfcs/rfc-2632-const-trait-impl/hir-const-check.stderr  | 2 +-
 .../rfc-2632-const-trait-impl/impl-tilde-const-trait.stderr   | 2 +-
 .../impl-with-default-fn-fail.stderr                          | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/issue-102985.stderr   | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/issue-79450.stderr    | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/issue-88155.stderr    | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/issue-92111.stderr    | 2 +-
 .../rfc-2632-const-trait-impl/match-non-const-eq.gated.stderr | 2 +-
 .../rfc-2632-const-trait-impl/match-non-const-eq.stock.stderr | 2 +-
 .../non-const-op-const-closure-non-const-outer.stderr         | 2 +-
 .../non-const-op-in-closure-in-const.stderr                   | 2 +-
 .../const-default-impl-non-const-specialized-impl.stderr      | 2 +-
 .../specialization/non-const-default-const-specialized.stderr | 2 +-
 .../rfc-2632-const-trait-impl/specializing-constness-2.stderr | 2 +-
 .../rfc-2632-const-trait-impl/specializing-constness.stderr   | 2 +-
 .../rfc-2632-const-trait-impl/staged-api-user-crate.stderr    | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/std-impl-gate.gated.stderr | 2 +-
 .../rfcs/rfc-2632-const-trait-impl/std-impl-gate.stock.stderr | 2 +-
 .../rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr   | 2 +-
 .../rfc-2632-const-trait-impl/super-traits-fail-2.yy.stderr   | 2 +-
 .../rfc-2632-const-trait-impl/super-traits-fail-3.yy.stderr   | 2 +-
 .../rfc-2632-const-trait-impl/tilde-const-maybe-trait.stderr  | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-twice.stderr    | 2 +-
 .../tilde_const_on_impl_bound.stderr                          | 2 +-
 tests/ui/rfcs/rfc-2632-const-trait-impl/without-tilde.stderr  | 2 +-
 tests/ui/rmeta/no_optitimized_mir.stderr                      | 2 +-
 tests/ui/rmeta/rmeta.stderr                                   | 2 +-
 tests/ui/rmeta/rmeta_lib.stderr                               | 2 +-
 tests/ui/rmeta/rmeta_meta_main.stderr                         | 2 +-
 tests/ui/rust-2018/async-ident-allowed.stderr                 | 2 +-
 tests/ui/rust-2018/dyn-keyword.stderr                         | 2 +-
 tests/ui/rust-2018/extern-crate-idiomatic-in-2018.stderr      | 2 +-
 tests/ui/rust-2018/extern-crate-rename.stderr                 | 2 +-
 tests/ui/rust-2018/extern-crate-submod.stderr                 | 2 +-
 tests/ui/rust-2018/issue-52202-use-suggestions.stderr         | 2 +-
 .../issue-54400-unused-extern-crate-attr-span.stderr          | 2 +-
 tests/ui/rust-2018/local-path-suggestions-2015.stderr         | 2 +-
 .../ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr | 2 +-
 tests/ui/rust-2018/uniform-paths/ambiguity-macros.stderr      | 2 +-
 tests/ui/rust-2018/uniform-paths/issue-54253.stderr           | 2 +-
 tests/ui/rust-2018/uniform-paths/issue-56596.stderr           | 2 +-
 tests/ui/rust-2018/uniform-paths/issue-87932.stderr           | 2 +-
 tests/ui/rust-2018/uniform-paths/macro-rules.stderr           | 2 +-
 tests/ui/rust-2018/uniform-paths/prelude-fail.stderr          | 2 +-
 tests/ui/rust-2018/unresolved-asterisk-imports.stderr         | 2 +-
 tests/ui/rust-2021/future-prelude-collision-shadow.stderr     | 2 +-
 tests/ui/rustc-error.stderr                                   | 2 +-
 tests/ui/rustdoc/cfg-rustdoc.stderr                           | 2 +-
 tests/ui/rustdoc/deny-invalid-doc-attrs.stderr                | 2 +-
 tests/ui/rustdoc/doc-alias-same-name.stderr                   | 2 +-
 tests/ui/rustdoc/doc-inline-extern-crate.stderr               | 2 +-
 tests/ui/rustdoc/doc-primitive.stderr                         | 2 +-
 tests/ui/rustdoc/feature-gate-doc_primitive.stderr            | 2 +-
 tests/ui/rustdoc/unterminated-doc-comment.stderr              | 2 +-
 tests/ui/sanitize/crt-static.stderr                           | 2 +-
 tests/ui/sanitize/incompatible.stderr                         | 2 +-
 .../sanitizer-cfi-canonical-jump-tables-require-cfi.stderr    | 2 +-
 .../sanitizer-cfi-generalize-pointers-require-cfi.stderr      | 2 +-
 .../sanitize/sanitizer-cfi-invalid-attr-cfi-encoding.stderr   | 2 +-
 .../sanitizer-cfi-normalize-integers-require-cfi.stderr       | 2 +-
 tests/ui/sanitize/sanitizer-cfi-requires-lto.stderr           | 2 +-
 ...zer-cfi-with-rustc-lto-requires-single-codegen-unit.stderr | 2 +-
 tests/ui/sanitize/split-lto-unit-requires-lto.stderr          | 2 +-
 tests/ui/sanitize/unsupported-target.stderr                   | 2 +-
 .../ui/self/arbitrary-self-from-method-substs.default.stderr  | 2 +-
 .../ui/self/arbitrary-self-from-method-substs.feature.stderr  | 2 +-
 ...self-types-not-object-safe.object_safe_for_dispatch.stderr | 2 +-
 tests/ui/self/arbitrary_self_types_needing_mut_pin.stderr     | 2 +-
 .../arbitrary_self_types_pin_lifetime_impl_trait-async.stderr | 2 +-
 .../self/arbitrary_self_types_pin_lifetime_impl_trait.stderr  | 2 +-
 tests/ui/self/issue-61882-2.stderr                            | 2 +-
 tests/ui/self/point-at-arbitrary-self-type-method.stderr      | 2 +-
 .../ui/self/point-at-arbitrary-self-type-trait-method.stderr  | 2 +-
 tests/ui/self/self-vs-path-ambiguity.stderr                   | 2 +-
 tests/ui/shadowed/shadowed-trait-methods.stderr               | 2 +-
 tests/ui/simd/monomorphize-heterogeneous.stderr               | 2 +-
 tests/ui/simd/monomorphize-shuffle-index.generic.stderr       | 2 +-
 tests/ui/simd/type-generic-monomorphisation-empty.stderr      | 2 +-
 .../simd/type-generic-monomorphisation-non-primitive.stderr   | 2 +-
 tests/ui/simd/type-generic-monomorphisation-oversized.stderr  | 2 +-
 tests/ui/simd/type-generic-monomorphisation-wide-ptr.stderr   | 2 +-
 tests/ui/simd/type-generic-monomorphisation.stderr            | 2 +-
 tests/ui/simd/type-wide-ptr.stderr                            | 2 +-
 .../one-use-in-inherent-impl-header.stderr                    | 2 +-
 .../one-use-in-inherent-method-return.stderr                  | 2 +-
 .../one-use-in-trait-method-argument.stderr                   | 2 +-
 .../two-uses-in-inherent-method-argument-and-return.stderr    | 2 +-
 tests/ui/single-use-lifetime/zero-uses-in-impl.stderr         | 2 +-
 tests/ui/sized-cycle-note.stderr                              | 2 +-
 tests/ui/sized/recursive-type-2.stderr                        | 2 +-
 tests/ui/sized/unsized-binding.stderr                         | 2 +-
 tests/ui/span/E0046.stderr                                    | 2 +-
 tests/ui/span/E0072.stderr                                    | 2 +-
 tests/ui/span/E0493.stderr                                    | 2 +-
 tests/ui/span/E0535.stderr                                    | 2 +-
 tests/ui/span/E0536.stderr                                    | 2 +-
 tests/ui/span/E0537.stderr                                    | 2 +-
 tests/ui/span/borrowck-call-method-from-mut-aliasable.stderr  | 2 +-
 tests/ui/span/borrowck-fn-in-const-b.stderr                   | 2 +-
 tests/ui/span/borrowck-ref-into-rvalue.stderr                 | 2 +-
 tests/ui/span/destructor-restrictions.stderr                  | 2 +-
 ...error-rust-2021-incompatible-closure-captures-93117.stderr | 2 +-
 tests/ui/span/dropck-object-cycle.stderr                      | 2 +-
 tests/ui/span/gated-features-attr-spans.stderr                | 2 +-
 tests/ui/span/issue-11925.stderr                              | 2 +-
 tests/ui/span/issue-15480.stderr                              | 2 +-
 tests/ui/span/issue-23729.stderr                              | 2 +-
 tests/ui/span/issue-23827.stderr                              | 2 +-
 tests/ui/span/issue-24356.stderr                              | 2 +-
 .../span/issue-24805-dropck-child-has-items-via-parent.stderr | 2 +-
 tests/ui/span/issue-24895-copy-clone-dropck.stderr            | 2 +-
 tests/ui/span/issue-25199.stderr                              | 2 +-
 tests/ui/span/issue-26656.stderr                              | 2 +-
 tests/ui/span/issue-27522.stderr                              | 2 +-
 tests/ui/span/issue-29595.stderr                              | 2 +-
 tests/ui/span/issue-33884.stderr                              | 2 +-
 tests/ui/span/issue-35987.stderr                              | 2 +-
 tests/ui/span/issue-36537.stderr                              | 2 +-
 tests/ui/span/issue-40157.stderr                              | 2 +-
 tests/ui/span/issue28498-reject-ex1.stderr                    | 2 +-
 tests/ui/span/issue28498-reject-lifetime-param.stderr         | 2 +-
 tests/ui/span/issue28498-reject-passed-to-fn.stderr           | 2 +-
 tests/ui/span/issue28498-reject-trait-bound.stderr            | 2 +-
 tests/ui/span/move-closure.stderr                             | 2 +-
 tests/ui/span/multiline-span-E0072.stderr                     | 2 +-
 tests/ui/span/multiline-span-simple.stderr                    | 2 +-
 tests/ui/span/mut-ptr-cant-outlive-ref.stderr                 | 2 +-
 tests/ui/span/non-existing-module-import.stderr               | 2 +-
 tests/ui/span/recursive-type-field.stderr                     | 2 +-
 tests/ui/span/regionck-unboxed-closure-lifetimes.stderr       | 2 +-
 tests/ui/span/regions-close-over-borrowed-ref-in-obj.stderr   | 2 +-
 tests/ui/span/regions-close-over-type-parameter-2.stderr      | 2 +-
 tests/ui/span/regions-escape-loop-via-variable.stderr         | 2 +-
 tests/ui/span/regions-infer-borrow-scope-within-loop.stderr   | 2 +-
 tests/ui/span/slice-borrow.stderr                             | 2 +-
 tests/ui/span/suggestion-non-ascii.stderr                     | 2 +-
 tests/ui/span/transitive-dep-span.stderr                      | 2 +-
 tests/ui/span/type-annotations-needed-expr.stderr             | 2 +-
 tests/ui/span/type-binding.stderr                             | 2 +-
 tests/ui/span/wf-method-late-bound-regions.stderr             | 2 +-
 .../ui/specialization/default-associated-type-bound-1.stderr  | 2 +-
 .../ui/specialization/default-associated-type-bound-2.stderr  | 2 +-
 .../default-generic-associated-type-bound.stderr              | 2 +-
 .../defaultimpl/specialization-feature-gate-default.stderr    | 2 +-
 .../specialization-trait-item-not-implemented.stderr          | 2 +-
 .../defaultimpl/specialization-trait-not-implemented.stderr   | 2 +-
 .../specialization/defaultimpl/specialization-wfcheck.stderr  | 2 +-
 tests/ui/specialization/issue-111232.stderr                   | 2 +-
 tests/ui/specialization/issue-33017.stderr                    | 2 +-
 tests/ui/specialization/issue-38091-2.stderr                  | 2 +-
 tests/ui/specialization/issue-38091.stderr                    | 2 +-
 tests/ui/specialization/issue-39448.stderr                    | 2 +-
 tests/ui/specialization/issue-43037.current.stderr            | 2 +-
 tests/ui/specialization/issue-43037.negative.stderr           | 2 +-
 tests/ui/specialization/issue-44861.stderr                    | 2 +-
 tests/ui/specialization/issue-45814.current.stderr            | 2 +-
 tests/ui/specialization/issue-45814.negative.stderr           | 2 +-
 tests/ui/specialization/issue-50452-fail.stderr               | 2 +-
 tests/ui/specialization/issue-51892.stderr                    | 2 +-
 tests/ui/specialization/issue-52050.stderr                    | 2 +-
 tests/ui/specialization/issue-59435.stderr                    | 2 +-
 .../ui/specialization/issue-68830-spurious-diagnostics.stderr | 2 +-
 .../min_specialization/bad-const-wf-doesnt-specialize.stderr  | 2 +-
 .../min_specialization/impl-on-nonexisting.stderr             | 2 +-
 .../min_specialization/impl_specialization_trait.stderr       | 2 +-
 .../min_specialization/repeated_projection_type.stderr        | 2 +-
 .../min_specialization/repeating_lifetimes.stderr             | 2 +-
 .../specialization/min_specialization/repeating_param.stderr  | 2 +-
 .../min_specialization/spec-marker-supertraits.stderr         | 2 +-
 .../min_specialization/specialization_super_trait.stderr      | 2 +-
 .../min_specialization/specialize_nothing.stderr              | 2 +-
 .../min_specialization/specialize_on_static.stderr            | 2 +-
 .../min_specialization/specialize_on_trait.stderr             | 2 +-
 .../min_specialization/specialize_on_type_error.stderr        | 2 +-
 ...ecialization-default-items-drop-coherence.coherence.stderr | 2 +-
 .../specialization-default-items-drop-coherence.next.stderr   | 2 +-
 .../specialization/specialization-feature-gate-default.stderr | 2 +-
 .../specialization/specialization-feature-gate-overlap.stderr | 2 +-
 tests/ui/specialization/specialization-overlap-hygiene.stderr | 2 +-
 .../ui/specialization/specialization-overlap-negative.stderr  | 2 +-
 .../stability-attribute/accidental-stable-in-unstable.stderr  | 2 +-
 tests/ui/stability-attribute/allowed-through-unstable.stderr  | 2 +-
 .../const-stability-attribute-implies-missing.stderr          | 2 +-
 .../const-stability-attribute-implies-no-feature.stderr       | 2 +-
 .../const-stability-attribute-implies-using-stable.stderr     | 2 +-
 .../const-stability-attribute-implies-using-unstable.stderr   | 2 +-
 .../generics-default-stability-where.stderr                   | 2 +-
 tests/ui/stability-attribute/issue-28075.stderr               | 2 +-
 tests/ui/stability-attribute/issue-28388-3.stderr             | 2 +-
 .../missing-stability-attr-at-top-level.stderr                | 2 +-
 .../stability-attribute-implies-missing.stderr                | 2 +-
 .../stability-attribute-implies-using-stable.stderr           | 2 +-
 .../stability-attribute-implies-using-unstable.stderr         | 2 +-
 .../stability-attribute/stability-attribute-sanity-3.stderr   | 2 +-
 .../ui/stability-attribute/stability-in-private-module.stderr | 2 +-
 tests/ui/stability-attribute/unresolved_stability_lint.stderr | 2 +-
 tests/ui/static/bad-const-type.stderr                         | 2 +-
 tests/ui/static/issue-18118-2.stderr                          | 2 +-
 tests/ui/static/issue-18118.stderr                            | 2 +-
 tests/ui/static/static-closures.stderr                        | 2 +-
 tests/ui/static/static-items-cant-move.stderr                 | 2 +-
 tests/ui/static/static-lifetime-bound.stderr                  | 2 +-
 tests/ui/static/static-lifetime.stderr                        | 2 +-
 tests/ui/static/static-method-privacy.stderr                  | 2 +-
 tests/ui/static/static-mut-bad-types.stderr                   | 2 +-
 tests/ui/static/static-mut-not-constant.stderr                | 2 +-
 tests/ui/static/static-reference-to-fn-1.stderr               | 2 +-
 tests/ui/static/static-region-bound.stderr                    | 2 +-
 tests/ui/static/static-vec-repeat-not-constant.stderr         | 2 +-
 tests/ui/statics/issue-14227.mir.stderr                       | 2 +-
 tests/ui/statics/issue-14227.thir.stderr                      | 2 +-
 tests/ui/statics/issue-17718-static-sync.stderr               | 2 +-
 tests/ui/statics/issue-44373.stderr                           | 2 +-
 tests/ui/str/str-as-char.stderr                               | 2 +-
 tests/ui/str/str-concat-on-double-ref.stderr                  | 2 +-
 tests/ui/structs-enums/enum-rec/issue-17431-6.stderr          | 2 +-
 tests/ui/structs-enums/enum-rec/issue-17431-7.stderr          | 2 +-
 tests/ui/structs-enums/issue-103869.stderr                    | 2 +-
 tests/ui/structs-enums/issue-2718-a.stderr                    | 2 +-
 tests/ui/structs-enums/issue-3008-1.stderr                    | 2 +-
 tests/ui/structs-enums/issue-3008-2.stderr                    | 2 +-
 tests/ui/structs-enums/issue-3008-3.stderr                    | 2 +-
 .../struct-enum-ignoring-field-with-underscore.stderr         | 2 +-
 tests/ui/structs-enums/struct-rec/issue-17431-1.stderr        | 2 +-
 tests/ui/structs-enums/struct-rec/issue-17431-2.stderr        | 2 +-
 tests/ui/structs-enums/struct-rec/issue-17431-3.stderr        | 2 +-
 tests/ui/structs-enums/struct-rec/issue-17431-4.stderr        | 2 +-
 tests/ui/structs-enums/struct-rec/issue-17431-5.stderr        | 2 +-
 tests/ui/structs-enums/struct-rec/issue-74224.stderr          | 2 +-
 tests/ui/structs-enums/struct-rec/issue-84611.stderr          | 2 +-
 tests/ui/structs/incomplete-fn-in-struct-definition.stderr    | 2 +-
 tests/ui/structs/issue-80853.stderr                           | 2 +-
 tests/ui/structs/method-chain-expression-failure.stderr       | 2 +-
 tests/ui/structs/multi-line-fru-suggestion.stderr             | 2 +-
 tests/ui/structs/struct-duplicate-comma.stderr                | 2 +-
 tests/ui/structs/struct-fields-decl-dupe.stderr               | 2 +-
 tests/ui/structs/struct-fields-dupe.stderr                    | 2 +-
 tests/ui/structs/struct-fields-hints-no-dupe.stderr           | 2 +-
 tests/ui/structs/struct-fields-hints.stderr                   | 2 +-
 tests/ui/structs/struct-fields-missing.stderr                 | 2 +-
 tests/ui/structs/struct-fields-shorthand-unresolved.stderr    | 2 +-
 tests/ui/structs/struct-fields-shorthand.stderr               | 2 +-
 tests/ui/structs/struct-fields-too-many.stderr                | 2 +-
 tests/ui/structs/struct-fields-typo.stderr                    | 2 +-
 tests/ui/structs/struct-missing-comma.stderr                  | 2 +-
 tests/ui/structs/struct-path-alias-bounds.stderr              | 2 +-
 tests/ui/structs/unresolved-struct-with-fru.stderr            | 2 +-
 tests/ui/suggestions/abi-typo.stderr                          | 2 +-
 tests/ui/suggestions/as-ref-2.stderr                          | 2 +-
 tests/ui/suggestions/assoc-const-as-field.stderr              | 2 +-
 tests/ui/suggestions/assoc-const-as-fn.stderr                 | 2 +-
 tests/ui/suggestions/assoc-const-without-self.stderr          | 2 +-
 tests/ui/suggestions/assoc-type-in-method-return.stderr       | 2 +-
 tests/ui/suggestions/bad-infer-in-trait-impl.stderr           | 2 +-
 tests/ui/suggestions/box-future-wrong-output.stderr           | 2 +-
 tests/ui/suggestions/boxed-variant-field.stderr               | 2 +-
 tests/ui/suggestions/call-boxed.stderr                        | 2 +-
 tests/ui/suggestions/call-on-unimplemented-ctor.stderr        | 2 +-
 tests/ui/suggestions/call-on-unimplemented-fn-ptr.stderr      | 2 +-
 .../suggestions/call-on-unimplemented-with-autoderef.stderr   | 2 +-
 tests/ui/suggestions/const-in-struct-pat.stderr               | 2 +-
 .../ui/suggestions/const-pat-non-exaustive-let-new-var.stderr | 2 +-
 tests/ui/suggestions/constrain-suggest-ice.stderr             | 2 +-
 tests/ui/suggestions/core-std-import-order-issue-83564.stderr | 2 +-
 .../correct-binder-for-arbitrary-bound-sugg.stderr            | 2 +-
 tests/ui/suggestions/deref-path-method.stderr                 | 2 +-
 tests/ui/suggestions/derive-clone-for-eq.stderr               | 2 +-
 .../dont-suggest-deref-inside-macro-issue-58298.stderr        | 2 +-
 .../hidden-child.stderr                                       | 2 +-
 .../hidden-parent.stderr                                      | 2 +-
 tests/ui/suggestions/dont-suggest-pin-array-dot-set.stderr    | 2 +-
 tests/ui/suggestions/dont-suggest-try_into-in-macros.stderr   | 2 +-
 tests/ui/suggestions/dont-suggest-ufcs-for-const.stderr       | 2 +-
 tests/ui/suggestions/dont-wrap-ambiguous-receivers.stderr     | 2 +-
 tests/ui/suggestions/enum-variant-arg-mismatch.stderr         | 2 +-
 tests/ui/suggestions/field-access-considering-privacy.stderr  | 2 +-
 tests/ui/suggestions/field-has-method.stderr                  | 2 +-
 .../suggestions/fn-needing-specified-return-type-param.stderr | 2 +-
 .../imm-ref-trait-object-literal-bound-regions.stderr         | 2 +-
 tests/ui/suggestions/imm-ref-trait-object.stderr              | 2 +-
 .../impl-trait-with-missing-trait-bounds-in-arg.stderr        | 2 +-
 tests/ui/suggestions/into-str.stderr                          | 2 +-
 tests/ui/suggestions/invalid-bin-op.stderr                    | 2 +-
 tests/ui/suggestions/issue-101065.stderr                      | 2 +-
 tests/ui/suggestions/issue-101421.stderr                      | 2 +-
 tests/ui/suggestions/issue-101465.stderr                      | 2 +-
 tests/ui/suggestions/issue-101623.stderr                      | 2 +-
 tests/ui/suggestions/issue-101984.stderr                      | 2 +-
 tests/ui/suggestions/issue-102354.stderr                      | 2 +-
 tests/ui/suggestions/issue-103112.stderr                      | 2 +-
 tests/ui/suggestions/issue-103646.stderr                      | 2 +-
 tests/ui/suggestions/issue-104327.stderr                      | 2 +-
 tests/ui/suggestions/issue-104328.stderr                      | 2 +-
 tests/ui/suggestions/issue-105645.stderr                      | 2 +-
 tests/ui/suggestions/issue-107860.stderr                      | 2 +-
 tests/ui/suggestions/issue-109291.stderr                      | 2 +-
 tests/ui/suggestions/issue-109436.stderr                      | 2 +-
 tests/ui/suggestions/issue-109854.stderr                      | 2 +-
 tests/ui/suggestions/issue-114701.stderr                      | 2 +-
 tests/ui/suggestions/issue-117669.stderr                      | 2 +-
 ...ssue-51055-missing-semicolon-between-call-and-tuple.stderr | 2 +-
 tests/ui/suggestions/issue-61226.stderr                       | 2 +-
 tests/ui/suggestions/issue-62843.stderr                       | 2 +-
 tests/ui/suggestions/issue-66968-suggest-sorted-words.stderr  | 2 +-
 tests/ui/suggestions/issue-68049-1.stderr                     | 2 +-
 tests/ui/suggestions/issue-71394-no-from-impl.stderr          | 2 +-
 tests/ui/suggestions/issue-72766.stderr                       | 2 +-
 tests/ui/suggestions/issue-81839.stderr                       | 2 +-
 tests/ui/suggestions/issue-83892.stderr                       | 2 +-
 tests/ui/suggestions/issue-83943.stderr                       | 2 +-
 tests/ui/suggestions/issue-84592.stderr                       | 2 +-
 tests/ui/suggestions/issue-84973-2.stderr                     | 2 +-
 tests/ui/suggestions/issue-84973.stderr                       | 2 +-
 ...5943-no-suggest-unsized-indirection-in-where-clause.stderr | 2 +-
 ...-85945-check-where-clause-before-suggesting-unsized.stderr | 2 +-
 tests/ui/suggestions/issue-88696.stderr                       | 2 +-
 tests/ui/suggestions/issue-89333.stderr                       | 2 +-
 tests/ui/suggestions/issue-89640.stderr                       | 2 +-
 .../issue-90213-expected-boxfuture-self-ice.stderr            | 2 +-
 tests/ui/suggestions/issue-90974.stderr                       | 2 +-
 tests/ui/suggestions/issue-96223.stderr                       | 2 +-
 tests/ui/suggestions/issue-97677.stderr                       | 2 +-
 tests/ui/suggestions/issue-97704.stderr                       | 2 +-
 tests/ui/suggestions/issue-97760.stderr                       | 2 +-
 tests/ui/suggestions/issue-98500.stderr                       | 2 +-
 tests/ui/suggestions/issue-98562.stderr                       | 2 +-
 tests/ui/suggestions/issue-99080.stderr                       | 2 +-
 tests/ui/suggestions/issue-99240-2.stderr                     | 2 +-
 tests/ui/suggestions/issue-99240.stderr                       | 2 +-
 tests/ui/suggestions/issue-99597.stderr                       | 2 +-
 .../js-style-comparison-op-separate-eq-token.stderr           | 2 +-
 tests/ui/suggestions/late-bound-in-borrow-closure-sugg.stderr | 2 +-
 .../lifetimes/missing-lifetimes-in-signature-2.stderr         | 2 +-
 .../missing-lifetimes-in-signature-before-const.stderr        | 2 +-
 ...ing-tick-underscore-lifetime-in-return-trait-object.stderr | 2 +-
 tests/ui/suggestions/many-type-ascription.stderr              | 2 +-
 tests/ui/suggestions/mismatched-types-numeric-from.stderr     | 2 +-
 .../missing-assoc-fn-applicable-suggestions.stderr            | 2 +-
 .../ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr | 2 +-
 .../ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr | 2 +-
 tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr | 2 +-
 .../ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr | 2 +-
 tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr | 2 +-
 tests/ui/suggestions/missing-type-param-used-in-param.stderr  | 2 +-
 .../move-generic-to-trait-in-method-with-params.stderr        | 2 +-
 tests/ui/suggestions/no-extern-crate-in-type.stderr           | 2 +-
 ...-existent-field-present-in-subfield-recursion-limit.stderr | 2 +-
 tests/ui/suggestions/opaque-type-error.stderr                 | 2 +-
 .../suggestions/option-content-move-from-tuple-match.stderr   | 2 +-
 tests/ui/suggestions/option-content-move2.stderr              | 2 +-
 tests/ui/suggestions/option-to-bool.stderr                    | 2 +-
 tests/ui/suggestions/path-by-value.stderr                     | 2 +-
 tests/ui/suggestions/private-field.stderr                     | 2 +-
 tests/ui/suggestions/remove-question-symbol-with-paren.stderr | 2 +-
 tests/ui/suggestions/restrict-type-not-param.stderr           | 2 +-
 tests/ui/suggestions/return-cycle-2.stderr                    | 2 +-
 tests/ui/suggestions/return-cycle.stderr                      | 2 +-
 tests/ui/suggestions/shadowed-lplace-method-2.stderr          | 2 +-
 tests/ui/suggestions/shadowed-lplace-method.stderr            | 2 +-
 tests/ui/suggestions/silenced-binding-typo.stderr             | 2 +-
 tests/ui/suggestions/sugg-else-for-closure.stderr             | 2 +-
 .../sugg_with_positional_args_and_debug_fmt.stderr            | 2 +-
 tests/ui/suggestions/suggest-assoc-fn-call-deref.stderr       | 2 +-
 .../suggest-assoc-fn-call-with-turbofish-placeholder.stderr   | 2 +-
 .../suggest-assoc-fn-call-with-turbofish-through-deref.stderr | 2 +-
 tests/ui/suggestions/suggest-box.stderr                       | 2 +-
 tests/ui/suggestions/suggest-closure-return-type-1.stderr     | 2 +-
 tests/ui/suggestions/suggest-closure-return-type-2.stderr     | 2 +-
 tests/ui/suggestions/suggest-closure-return-type-3.stderr     | 2 +-
 tests/ui/suggestions/suggest-dereferencing-index.stderr       | 2 +-
 .../suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr   | 2 +-
 .../suggest-full-enum-variant-for-local-module.stderr         | 2 +-
 tests/ui/suggestions/suggest-impl-trait-lifetime.stderr       | 2 +-
 .../ui/suggestions/suggest-mut-method-for-loop-closure.stderr | 2 +-
 .../ui/suggestions/suggest-mut-method-for-loop-hashmap.stderr | 2 +-
 tests/ui/suggestions/suggest-mut-method-for-loop.stderr       | 2 +-
 tests/ui/suggestions/suggest-pin-macro.stderr                 | 2 +-
 tests/ui/suggestions/suggest-remove-refs-1.stderr             | 2 +-
 tests/ui/suggestions/suggest-remove-refs-2.stderr             | 2 +-
 tests/ui/suggestions/suggest-remove-refs-3.stderr             | 2 +-
 tests/ui/suggestions/suggest-remove-refs-4.stderr             | 2 +-
 tests/ui/suggestions/suggest-ret-on-async-w-late.stderr       | 2 +-
 .../suggest-semicolon-for-fn-in-extern-block.stderr           | 2 +-
 tests/ui/suggestions/suggest-split-at-mut.stderr              | 2 +-
 tests/ui/suggestions/suggest-trait-in-ufcs-in-hrtb.stderr     | 2 +-
 tests/ui/suggestions/suggest_print_over_printf.stderr         | 2 +-
 tests/ui/suggestions/type-ascription-and-other-error.stderr   | 2 +-
 tests/ui/suggestions/type-ascription-instead-of-let.stderr    | 2 +-
 tests/ui/suggestions/type-ascription-instead-of-method.stderr | 2 +-
 tests/ui/suggestions/type-ascription-instead-of-path-2.stderr | 2 +-
 tests/ui/suggestions/type-ascription-instead-of-path.stderr   | 2 +-
 .../ui/suggestions/type-ascription-instead-of-variant.stderr  | 2 +-
 tests/ui/suggestions/undeclared-module-alloc.stderr           | 2 +-
 tests/ui/suggestions/use-placement-resolve.stderr             | 2 +-
 tests/ui/suggestions/use-placement-typeck.stderr              | 2 +-
 tests/ui/super-at-top-level.stderr                            | 2 +-
 tests/ui/svh/changing-crates.stderr                           | 2 +-
 tests/ui/svh/svh-change-lit.stderr                            | 2 +-
 tests/ui/svh/svh-change-significant-cfg.stderr                | 2 +-
 tests/ui/svh/svh-change-trait-bound.stderr                    | 2 +-
 tests/ui/svh/svh-change-type-arg.stderr                       | 2 +-
 tests/ui/svh/svh-change-type-ret.stderr                       | 2 +-
 tests/ui/svh/svh-change-type-static.stderr                    | 2 +-
 tests/ui/svh/svh-use-trait.stderr                             | 2 +-
 tests/ui/switched-expectations.stderr                         | 2 +-
 tests/ui/symbol-names/impl2.stderr                            | 2 +-
 tests/ui/sync/mutexguard-sync.stderr                          | 2 +-
 tests/ui/sync/suggest-once-cell.stderr                        | 2 +-
 tests/ui/sync/suggest-ref-cell.stderr                         | 2 +-
 tests/ui/tag-type-args.stderr                                 | 2 +-
 tests/ui/tag-variant-cast-non-nullary.stderr                  | 2 +-
 tests/ui/tail-typeck.stderr                                   | 2 +-
 tests/ui/target-feature/gate.stderr                           | 2 +-
 tests/ui/target-feature/tied-features-cli.one.stderr          | 2 +-
 tests/ui/target-feature/tied-features-cli.three.stderr        | 2 +-
 tests/ui/target-feature/tied-features-cli.two.stderr          | 2 +-
 .../ui/test-attrs/custom-test-frameworks/issue-107454.stderr  | 2 +-
 tests/ui/test-attrs/issue-109816.stderr                       | 2 +-
 tests/ui/test-attrs/issue-12997-2.stderr                      | 2 +-
 tests/ui/test-attrs/test-panic-abort-disabled.stderr          | 2 +-
 tests/ui/test-attrs/test-warns-dead-code.stderr               | 2 +-
 tests/ui/thread-local/thread-local-mutation.stderr            | 2 +-
 tests/ui/tool-attributes/diagnostic_item.stderr               | 2 +-
 tests/ui/tool-attributes/tool-attributes-shadowing.stderr     | 2 +-
 tests/ui/tool_lints-fail.stderr                               | 2 +-
 tests/ui/track-diagnostics/track2.stderr                      | 2 +-
 tests/ui/track-diagnostics/track4.stderr                      | 2 +-
 tests/ui/track-diagnostics/track5.stderr                      | 2 +-
 tests/ui/track-diagnostics/track6.stderr                      | 2 +-
 tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr    | 2 +-
 .../trait-bounds/impl-derived-implicit-sized-bound-2.stderr   | 2 +-
 .../ui/trait-bounds/impl-derived-implicit-sized-bound.stderr  | 2 +-
 tests/ui/trait-bounds/issue-82038.stderr                      | 2 +-
 .../trait-bounds/restrict-assoc-type-of-generic-bound.stderr  | 2 +-
 .../shadowed-path-in-trait-bound-suggestion.stderr            | 2 +-
 tests/ui/trait-impl-bound-suggestions.stderr                  | 2 +-
 tests/ui/trait-method-number-parameters.stderr                | 2 +-
 tests/ui/traits/alias/ambiguous.stderr                        | 2 +-
 tests/ui/traits/alias/dont-elaborate-non-self.stderr          | 2 +-
 tests/ui/traits/alias/impl.stderr                             | 2 +-
 .../traits/alias/issue-108072-unmet-trait-alias-bound.stderr  | 2 +-
 ...ssue-108132-unmet-trait-alias-bound-on-generic-impl.stderr | 2 +-
 tests/ui/traits/alias/issue-83613.stderr                      | 2 +-
 tests/ui/traits/alias/self-in-const-generics.stderr           | 2 +-
 tests/ui/traits/alias/self-in-generics.stderr                 | 2 +-
 .../traits/alias/suggest-trait-alias-instead-of-type.stderr   | 2 +-
 tests/ui/traits/alias/wf.stderr                               | 2 +-
 tests/ui/traits/as-struct-constructor.stderr                  | 2 +-
 tests/ui/traits/assoc-type-in-superbad.stderr                 | 2 +-
 .../associated_type_bound/check-trait-object-bounds-1.stderr  | 2 +-
 .../associated_type_bound/check-trait-object-bounds-2.stderr  | 2 +-
 .../associated_type_bound/check-trait-object-bounds-3.stderr  | 2 +-
 .../associated_type_bound/check-trait-object-bounds-4.stderr  | 2 +-
 .../associated_type_bound/check-trait-object-bounds-5.stderr  | 2 +-
 .../associated_type_bound/check-trait-object-bounds-6.stderr  | 2 +-
 tests/ui/traits/bad-method-typaram-kind.stderr                | 2 +-
 tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr   | 2 +-
 tests/ui/traits/bound/not-on-bare-trait.stderr                | 2 +-
 tests/ui/traits/bound/on-structs-and-enums-in-impls.stderr    | 2 +-
 tests/ui/traits/bound/sugar.stderr                            | 2 +-
 tests/ui/traits/cache-reached-depth-ice.stderr                | 2 +-
 tests/ui/traits/coercion-generic-bad.stderr                   | 2 +-
 tests/ui/traits/coercion-generic-regions.stderr               | 2 +-
 tests/ui/traits/copy-guessing.stderr                          | 2 +-
 tests/ui/traits/copy-impl-cannot-normalize.stderr             | 2 +-
 tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr  | 2 +-
 tests/ui/traits/cycle-cache-err-60010.stderr                  | 2 +-
 .../traits/default-method/rustc_must_implement_one_of.stderr  | 2 +-
 .../default-method/rustc_must_implement_one_of_gated.stderr   | 2 +-
 tests/ui/traits/deny-builtin-object-impl.current.stderr       | 2 +-
 tests/ui/traits/deny-builtin-object-impl.next.stderr          | 2 +-
 ...ntion-type-params-by-name-in-suggestion-issue-96292.stderr | 2 +-
 tests/ui/traits/duplicate-methods.stderr                      | 2 +-
 tests/ui/traits/ice-with-dyn-pointee-errors.stderr            | 2 +-
 tests/ui/traits/ignore-err-impls.stderr                       | 2 +-
 tests/ui/traits/impl-1.stderr                                 | 2 +-
 tests/ui/traits/impl-bounds-checking.stderr                   | 2 +-
 tests/ui/traits/impl-different-num-params.stderr              | 2 +-
 tests/ui/traits/impl-for-module.stderr                        | 2 +-
 tests/ui/traits/impl-method-mismatch.stderr                   | 2 +-
 .../impl-of-supertrait-has-wrong-lifetime-parameters.stderr   | 2 +-
 tests/ui/traits/inductive-overflow/lifetime.stderr            | 2 +-
 tests/ui/traits/inductive-overflow/simultaneous.stderr        | 2 +-
 tests/ui/traits/inductive-overflow/supertrait.stderr          | 2 +-
 tests/ui/traits/invalid_operator_trait.stderr                 | 2 +-
 tests/ui/traits/issue-18400.stderr                            | 2 +-
 tests/ui/traits/issue-22384.stderr                            | 2 +-
 tests/ui/traits/issue-28576.stderr                            | 2 +-
 tests/ui/traits/issue-43784-supertrait.stderr                 | 2 +-
 tests/ui/traits/issue-52893.stderr                            | 2 +-
 .../ui/traits/issue-65284-suggest-generic-trait-bound.stderr  | 2 +-
 tests/ui/traits/issue-65673.stderr                            | 2 +-
 tests/ui/traits/issue-68295.stderr                            | 2 +-
 tests/ui/traits/issue-7013.stderr                             | 2 +-
 tests/ui/traits/issue-71036.stderr                            | 2 +-
 tests/ui/traits/issue-71136.stderr                            | 2 +-
 tests/ui/traits/issue-72410.stderr                            | 2 +-
 tests/ui/traits/issue-75627.stderr                            | 2 +-
 tests/ui/traits/issue-79458.stderr                            | 2 +-
 tests/ui/traits/issue-8153.stderr                             | 2 +-
 tests/ui/traits/issue-85735.stderr                            | 2 +-
 tests/ui/traits/issue-91594.stderr                            | 2 +-
 tests/ui/traits/issue-91949-hangs-on-recursion.stderr         | 2 +-
 tests/ui/traits/issue-95898.stderr                            | 2 +-
 tests/ui/traits/issue-97576.stderr                            | 2 +-
 tests/ui/traits/map-types.stderr                              | 2 +-
 tests/ui/traits/method-private.stderr                         | 2 +-
 tests/ui/traits/multidispatch-bad.stderr                      | 2 +-
 tests/ui/traits/multidispatch-convert-ambig-dest.stderr       | 2 +-
 tests/ui/traits/mutual-recursion-issue-75860.stderr           | 2 +-
 .../traits/negative-impls/feature-gate-negative_impls.stderr  | 2 +-
 tests/ui/traits/negative-impls/negative-default-impls.stderr  | 2 +-
 .../negative-impls/negative-specializes-positive-item.stderr  | 2 +-
 .../negative-impls/negative-specializes-positive.stderr       | 2 +-
 tests/ui/traits/negative-impls/no-items.stderr                | 2 +-
 .../negative-impls/pin-unsound-issue-66544-clone.stderr       | 2 +-
 .../negative-impls/pin-unsound-issue-66544-derefmut.stderr    | 2 +-
 .../negative-impls/positive-specializes-negative.stderr       | 2 +-
 .../new-solver/alias_eq_substs_eq_not_intercrate.stderr       | 2 +-
 .../assembly/runaway-impl-candidate-selection.stderr          | 2 +-
 tests/ui/traits/new-solver/async.fail.stderr                  | 2 +-
 .../traits/new-solver/auto-with-drop_tracking_mir.fail.stderr | 2 +-
 tests/ui/traits/new-solver/borrowck-error.stderr              | 2 +-
 .../ui/traits/new-solver/builtin-fn-must-return-sized.stderr  | 2 +-
 tests/ui/traits/new-solver/coherence/issue-102048.stderr      | 2 +-
 .../coherence/trait_ref_is_knowable-norm-overflow.stderr      | 2 +-
 .../ui/traits/new-solver/const-param-placeholder.fail.stderr  | 2 +-
 .../cycles/coinduction/fixpoint-exponential-growth.stderr     | 2 +-
 .../cycles/coinduction/incompleteness-unstable-result.stderr  | 2 +-
 .../new-solver/cycles/fixpoint-rerun-all-cycle-heads.stderr   | 2 +-
 .../traits/new-solver/cycles/inductive-cycle-but-err.stderr   | 2 +-
 .../traits/new-solver/dont-normalize-proj-with-error.stderr   | 2 +-
 .../dont-type_of-tait-in-defining-scope.not_send.stderr       | 2 +-
 .../traits/new-solver/equating-projection-cyclically.stderr   | 2 +-
 .../generalize/generalize-proj-new-universe-index-2.stderr    | 2 +-
 tests/ui/traits/new-solver/more-object-bound.stderr           | 2 +-
 ...izes_to_ignores_unnormalizable_candidate.self_infer.stderr | 2 +-
 .../traits/new-solver/overflow/exponential-trait-goals.stderr | 2 +-
 tests/ui/traits/new-solver/overflow/global-cache.stderr       | 2 +-
 tests/ui/traits/new-solver/pointer-like.stderr                | 2 +-
 tests/ui/traits/new-solver/projection-discr-kind.stderr       | 2 +-
 .../new-solver/stall-num-var-auto-trait.fallback.stderr       | 2 +-
 .../two-projection-param-candidates-are-ambiguous.stderr      | 2 +-
 .../new-solver/unevaluated-const-impl-trait-ref.fails.stderr  | 2 +-
 tests/ui/traits/new-solver/upcast-wrong-substs.stderr         | 2 +-
 tests/ui/traits/no-fallback-multiple-impls.stderr             | 2 +-
 tests/ui/traits/no_send-struct.stderr                         | 2 +-
 tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr     | 2 +-
 .../non_lifetime_binders/capture-late-ct-in-anon.stderr       | 2 +-
 tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr | 2 +-
 .../ui/traits/non_lifetime_binders/foreach-partial-eq.stderr  | 2 +-
 .../traits/non_lifetime_binders/late-bound-in-anon-ct.stderr  | 2 +-
 .../ui/traits/non_lifetime_binders/missing-assoc-item.stderr  | 2 +-
 .../nested-apit-mentioning-outer-bound-var.stderr             | 2 +-
 tests/ui/traits/non_lifetime_binders/on-dyn.stderr            | 2 +-
 tests/ui/traits/non_lifetime_binders/on-ptr.stderr            | 2 +-
 .../placeholders-dont-outlive-static.bad.stderr               | 2 +-
 .../placeholders-dont-outlive-static.good.stderr              | 2 +-
 .../non_lifetime_binders/type-match-with-late-bound.stderr    | 2 +-
 tests/ui/traits/non_lifetime_binders/universe-error1.stderr   | 2 +-
 .../not-suggest-non-existing-fully-qualified-path.stderr      | 2 +-
 tests/ui/traits/object-does-not-impl-trait.stderr             | 2 +-
 tests/ui/traits/object/auto-dedup-in-impl.stderr              | 2 +-
 tests/ui/traits/object/enforce-supertrait-projection.stderr   | 2 +-
 tests/ui/traits/object/issue-44454-1.stderr                   | 2 +-
 tests/ui/traits/object/issue-44454-2.stderr                   | 2 +-
 tests/ui/traits/object/issue-44454-3.stderr                   | 2 +-
 .../ui/traits/object/object-unsafe-missing-assoc-type.stderr  | 2 +-
 tests/ui/traits/object/supertrait-lifetime-bound.stderr       | 2 +-
 tests/ui/traits/object/vs-lifetime-2.stderr                   | 2 +-
 .../ui/traits/overlap-not-permitted-for-builtin-trait.stderr  | 2 +-
 tests/ui/traits/param-without-lifetime-constraint.stderr      | 2 +-
 tests/ui/traits/project-modulo-regions.with_clause.stderr     | 2 +-
 tests/ui/traits/project-modulo-regions.without_clause.stderr  | 2 +-
 .../ui/traits/reservation-impl/coherence-conflict.next.stderr | 2 +-
 .../ui/traits/reservation-impl/coherence-conflict.old.stderr  | 2 +-
 tests/ui/traits/reservation-impl/no-use.next.stderr           | 2 +-
 tests/ui/traits/reservation-impl/no-use.old.stderr            | 2 +-
 tests/ui/traits/resolution-in-overloaded-op.stderr            | 2 +-
 tests/ui/traits/safety-fn-body.mir.stderr                     | 2 +-
 tests/ui/traits/safety-fn-body.thir.stderr                    | 2 +-
 tests/ui/traits/safety-inherent-impl.stderr                   | 2 +-
 tests/ui/traits/safety-trait-impl-cc.stderr                   | 2 +-
 tests/ui/traits/self-without-lifetime-constraint.stderr       | 2 +-
 .../solver-cycles/cycle-via-builtin-auto-trait-impl.stderr    | 2 +-
 tests/ui/traits/static-method-generic-inference.stderr        | 2 +-
 tests/ui/traits/staticness-mismatch.stderr                    | 2 +-
 .../suggest-dereferences/dont-suggest-unsize-deref.stderr     | 2 +-
 tests/ui/traits/suggest-dereferences/issue-39029.stderr       | 2 +-
 tests/ui/traits/suggest-dereferences/issue-62530.stderr       | 2 +-
 tests/ui/traits/suggest-dereferences/multiple-0.stderr        | 2 +-
 tests/ui/traits/suggest-dereferences/multiple-1.stderr        | 2 +-
 tests/ui/traits/suggest-dereferences/root-obligation.stderr   | 2 +-
 .../suggest-dereferencing-receiver-argument.stderr            | 2 +-
 tests/ui/traits/suggest-fully-qualified-closure.stderr        | 2 +-
 tests/ui/traits/test.stderr                                   | 2 +-
 tests/ui/traits/trait-object-lifetime-default-note.stderr     | 2 +-
 tests/ui/traits/trait-or-new-type-instead.stderr              | 2 +-
 .../trait-upcasting/alias-where-clause-isnt-supertrait.stderr | 2 +-
 .../ui/traits/trait-upcasting/cyclic-trait-resolution.stderr  | 2 +-
 .../trait-upcasting/deref-upcast-behavioral-change.stderr     | 2 +-
 .../trait-upcasting/illegal-upcast-from-impl.current.stderr   | 2 +-
 .../trait-upcasting/illegal-upcast-from-impl.next.stderr      | 2 +-
 .../trait-upcasting/inference-behavior-change-deref.stderr    | 2 +-
 .../trait-upcasting/multiple-occurrence-ambiguousity.stderr   | 2 +-
 .../trait-upcasting/multiple_supertrait_upcastable.stderr     | 2 +-
 .../trait-upcasting/type-checking-test-1.current.stderr       | 2 +-
 .../traits/trait-upcasting/type-checking-test-1.next.stderr   | 2 +-
 tests/ui/traits/trivial_impl.stderr                           | 2 +-
 tests/ui/traits/trivial_impl2.stderr                          | 2 +-
 tests/ui/traits/trivial_impl3.stderr                          | 2 +-
 tests/ui/traits/trivial_impl4.stderr                          | 2 +-
 tests/ui/traits/unsend-future.stderr                          | 2 +-
 tests/ui/traits/vtable-res-trait-param.stderr                 | 2 +-
 tests/ui/traits/vtable/issue-97381.stderr                     | 2 +-
 tests/ui/traits/vtable/vtable-non-object-safe.stderr          | 2 +-
 tests/ui/traits/vtable/vtable-vacant.stderr                   | 2 +-
 tests/ui/transmutability/alignment/align-fail.stderr          | 2 +-
 .../transmutability/arrays/issue-103783-array-length.stderr   | 2 +-
 tests/ui/transmutability/enums/should_pad_variants.stderr     | 2 +-
 .../ui/transmutability/enums/should_respect_endianness.stderr | 2 +-
 tests/ui/transmutability/issue-101739-2.stderr                | 2 +-
 .../malformed-program-gracefulness/unknown_dst.stderr         | 2 +-
 .../malformed-program-gracefulness/unknown_src.stderr         | 2 +-
 tests/ui/transmutability/primitives/bool-mut.stderr           | 2 +-
 tests/ui/transmutability/primitives/bool.current.stderr       | 2 +-
 tests/ui/transmutability/primitives/bool.next.stderr          | 2 +-
 tests/ui/transmutability/primitives/unit.current.stderr       | 2 +-
 tests/ui/transmutability/primitives/unit.next.stderr          | 2 +-
 .../recursive-wrapper-types-bit-compatible-mut.stderr         | 2 +-
 .../recursive-wrapper-types-bit-incompatible.stderr           | 2 +-
 tests/ui/transmutability/references/unit-to-u8.stderr         | 2 +-
 tests/ui/transmutability/region-infer.stderr                  | 2 +-
 tests/ui/transmutability/unions/should_pad_variants.stderr    | 2 +-
 .../transmutability/unions/should_reject_contraction.stderr   | 2 +-
 .../assume/should_accept_if_dst_has_unreachable_ty.stderr     | 2 +-
 .../visibility/should_accept_if_src_has_unreachable_ty.stderr | 2 +-
 .../visibility/should_reject_if_dst_has_private_field.stderr  | 2 +-
 .../should_reject_if_dst_has_private_variant.stderr           | 2 +-
 .../should_reject_if_dst_has_unreachable_field.stderr         | 2 +-
 tests/ui/transmute/transmute-impl.stderr                      | 2 +-
 tests/ui/transmute/transmute-imut-to-mut.stderr               | 2 +-
 tests/ui/transmute/transmute-padding-ice.stderr               | 2 +-
 .../trivial-bounds-inconsistent-projection-error.stderr       | 2 +-
 tests/ui/trivial-bounds/trivial-bounds-leak-copy.stderr       | 2 +-
 tests/ui/try-block/try-block-catch.stderr                     | 2 +-
 tests/ui/try-block/try-block-in-while.stderr                  | 2 +-
 tests/ui/try-block/try-block-opt-init.stderr                  | 2 +-
 tests/ui/try-trait/issue-32709.stderr                         | 2 +-
 tests/ui/tuple/array-diagnostics.stderr                       | 2 +-
 tests/ui/tuple/wrong_argument_ice-2.stderr                    | 2 +-
 tests/ui/tuple/wrong_argument_ice-3.stderr                    | 2 +-
 tests/ui/tuple/wrong_argument_ice-4.stderr                    | 2 +-
 tests/ui/tuple/wrong_argument_ice.stderr                      | 2 +-
 .../incorrect-variant-form-through-Self-issue-58006.stderr    | 2 +-
 .../no-type-application-on-aliased-enum-variant.stderr        | 2 +-
 ...resolve-to-enum-variant-in-type-namespace-and-error.stderr | 2 +-
 .../type-alias-enum-variants/self-in-enum-definition.stderr   | 2 +-
 .../assoc-type-lifetime-unconstrained.stderr                  | 2 +-
 tests/ui/type-alias-impl-trait/auto-trait-leakage2.stderr     | 2 +-
 tests/ui/type-alias-impl-trait/auto-trait-leakage3.stderr     | 2 +-
 tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr    | 2 +-
 tests/ui/type-alias-impl-trait/bounds-are-checked.stderr      | 2 +-
 tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr     | 2 +-
 tests/ui/type-alias-impl-trait/coherence.stderr               | 2 +-
 tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr   | 2 +-
 .../coherence_different_hidden_ty.stderr                      | 2 +-
 .../ui/type-alias-impl-trait/constrain_inputs_unsound.stderr  | 2 +-
 .../type-alias-impl-trait/declared_but_never_defined.stderr   | 2 +-
 tests/ui/type-alias-impl-trait/different_defining_uses.stderr | 2 +-
 .../different_defining_uses_never_type-2.stderr               | 2 +-
 .../different_defining_uses_never_type-3.stderr               | 2 +-
 .../different_defining_uses_never_type.stderr                 | 2 +-
 .../different_defining_uses_never_type3.stderr                | 2 +-
 .../different_lifetimes_defining_uses.stderr                  | 2 +-
 tests/ui/type-alias-impl-trait/escaping-bound-var.stderr      | 2 +-
 tests/ui/type-alias-impl-trait/fallback.stderr                | 2 +-
 tests/ui/type-alias-impl-trait/future.stderr                  | 2 +-
 .../generic_different_defining_uses.stderr                    | 2 +-
 .../type-alias-impl-trait/generic_duplicate_param_use2.stderr | 2 +-
 .../type-alias-impl-trait/generic_duplicate_param_use4.stderr | 2 +-
 .../hidden_behind_projection_behind_struct_field.stderr       | 2 +-
 tests/ui/type-alias-impl-trait/hidden_type_mismatch.stderr    | 2 +-
 tests/ui/type-alias-impl-trait/higher_kinded_params2.stderr   | 2 +-
 .../impl-with-unconstrained-param.stderr                      | 2 +-
 tests/ui/type-alias-impl-trait/impl_for_weak_alias.stderr     | 2 +-
 .../ui/type-alias-impl-trait/impl_trait_for_tait_bound.stderr | 2 +-
 .../type-alias-impl-trait/impl_trait_for_tait_bound2.stderr   | 2 +-
 tests/ui/type-alias-impl-trait/implied_bounds.stderr          | 2 +-
 tests/ui/type-alias-impl-trait/implied_bounds_closure.stderr  | 2 +-
 .../ui/type-alias-impl-trait/implied_bounds_from_types.stderr | 2 +-
 .../implied_lifetime_wf_check4_static.stderr                  | 2 +-
 .../imply_bounds_from_bounds_param.stderr                     | 2 +-
 .../type-alias-impl-trait/incoherent-assoc-imp-trait.stderr   | 2 +-
 tests/ui/type-alias-impl-trait/incomplete-inference.stderr    | 2 +-
 .../indirect-recursion-issue-112047.stderr                    | 2 +-
 tests/ui/type-alias-impl-trait/inference-cycle.stderr         | 2 +-
 .../infinite-cycle-involving-weak.stderr                      | 2 +-
 .../invalid_impl_trait_in_assoc_ty.stderr                     | 2 +-
 tests/ui/type-alias-impl-trait/issue-104817.stock.stderr      | 2 +-
 tests/ui/type-alias-impl-trait/issue-109054.stderr            | 2 +-
 .../issue-52843-closure-constrain.stderr                      | 2 +-
 tests/ui/type-alias-impl-trait/issue-52843.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-53092.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-53096.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-53598.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-57700.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-57961.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-60407.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-65384.stderr             | 2 +-
 .../issue-69136-inner-lifetime-resolve-error.stderr           | 2 +-
 tests/ui/type-alias-impl-trait/issue-70121.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-74244.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-74280.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-77179.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-84660-unsoundness.stderr | 2 +-
 tests/ui/type-alias-impl-trait/issue-89686.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-90400-1.stderr           | 2 +-
 tests/ui/type-alias-impl-trait/issue-90400-2.stderr           | 2 +-
 tests/ui/type-alias-impl-trait/issue-94429.stderr             | 2 +-
 .../issue-96572-unconstrained-mismatch.stderr                 | 2 +-
 tests/ui/type-alias-impl-trait/issue-98604.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/issue-98608.stderr             | 2 +-
 tests/ui/type-alias-impl-trait/missing_lifetime_bound.stderr  | 2 +-
 tests/ui/type-alias-impl-trait/multi-error.stderr             | 2 +-
 .../multiple-def-uses-in-one-fn-infer.stderr                  | 2 +-
 .../multiple-def-uses-in-one-fn-lifetimes.stderr              | 2 +-
 .../type-alias-impl-trait/multiple-def-uses-in-one-fn.stderr  | 2 +-
 .../type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr | 2 +-
 .../type-alias-impl-trait/multiple-def-uses-in-one-fn3.stderr | 2 +-
 .../type-alias-impl-trait/mututally-recursive-overflow.stderr | 2 +-
 tests/ui/type-alias-impl-trait/nested-tait-inference.stderr   | 2 +-
 tests/ui/type-alias-impl-trait/nested-tait-inference2.stderr  | 2 +-
 tests/ui/type-alias-impl-trait/nested-tait-inference3.stderr  | 2 +-
 tests/ui/type-alias-impl-trait/nested.stderr                  | 2 +-
 .../type-alias-impl-trait/nested_type_alias_impl_trait.stderr | 2 +-
 .../type-alias-impl-trait/no_inferrable_concrete_type.stderr  | 2 +-
 tests/ui/type-alias-impl-trait/non-defining-method.stderr     | 2 +-
 .../not-matching-trait-refs-isnt-defining.stderr              | 2 +-
 tests/ui/type-alias-impl-trait/not_well_formed.stderr         | 2 +-
 tests/ui/type-alias-impl-trait/recursive-fn-tait.stderr       | 2 +-
 .../recursive-tait-conflicting-defn-2.stderr                  | 2 +-
 .../recursive-tait-conflicting-defn.stderr                    | 2 +-
 tests/ui/type-alias-impl-trait/self-referential-2.stderr      | 2 +-
 tests/ui/type-alias-impl-trait/self-referential-3.stderr      | 2 +-
 .../ui/type-alias-impl-trait/structural-match-no-leak.stderr  | 2 +-
 tests/ui/type-alias-impl-trait/structural-match.stderr        | 2 +-
 .../type-alias-impl-trait-fn-type.stderr                      | 2 +-
 .../type-alias-impl-trait-unconstrained-lifetime.stderr       | 2 +-
 .../type-alias-impl-trait-with-cycle-error.stderr             | 2 +-
 .../type-alias-impl-trait-with-cycle-error2.stderr            | 2 +-
 .../unconstrained-due-to-bad-pattern.stderr                   | 2 +-
 .../ui/type-alias-impl-trait/unconstrained-impl-param.stderr  | 2 +-
 tests/ui/type-alias-impl-trait/under-binder.stderr            | 2 +-
 .../ui/type-alias-impl-trait/underconstrained_generic.stderr  | 2 +-
 .../ui/type-alias-impl-trait/underconstrained_lifetime.stderr | 2 +-
 tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr         | 2 +-
 tests/ui/type-alias-impl-trait/wf-nested.fail.stderr          | 2 +-
 tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr    | 2 +-
 tests/ui/type-alias-impl-trait/wf_check_closures.stderr       | 2 +-
 tests/ui/type-alias/issue-62263-self-in-atb.stderr            | 2 +-
 tests/ui/type-alias/issue-62305-self-assoc-ty.stderr          | 2 +-
 tests/ui/type-alias/issue-62364-self-ty-arg.stderr            | 2 +-
 tests/ui/type-inference/issue-30225.stderr                    | 2 +-
 tests/ui/type-inference/or_else-multiple-type-params.stderr   | 2 +-
 tests/ui/type-inference/sort_by_key.stderr                    | 2 +-
 tests/ui/type-inference/unbounded-associated-type.stderr      | 2 +-
 .../unbounded-type-param-in-fn-with-assoc-type.stderr         | 2 +-
 tests/ui/type-inference/unbounded-type-param-in-fn.stderr     | 2 +-
 tests/ui/type/ascription/issue-34255-1.stderr                 | 2 +-
 tests/ui/type/ascription/issue-47666.stderr                   | 2 +-
 tests/ui/type/ascription/issue-54516.stderr                   | 2 +-
 tests/ui/type/ascription/issue-60933.stderr                   | 2 +-
 tests/ui/type/closure-with-wrong-borrows.stderr               | 2 +-
 tests/ui/type/issue-101866.stderr                             | 2 +-
 tests/ui/type/issue-58355.stderr                              | 2 +-
 tests/ui/type/issue-91268.stderr                              | 2 +-
 tests/ui/type/missing-let-in-binding-2.stderr                 | 2 +-
 tests/ui/type/missing-let-in-binding-3.stderr                 | 2 +-
 tests/ui/type/missing-let-in-binding-4.stderr                 | 2 +-
 tests/ui/type/missing-let-in-binding.stderr                   | 2 +-
 tests/ui/type/type-annotation-needed.stderr                   | 2 +-
 tests/ui/type/type-ascription-with-fn-call.stderr             | 2 +-
 tests/ui/type/type-check/cannot_infer_local_or_array.stderr   | 2 +-
 tests/ui/type/type-check/cannot_infer_local_or_vec.stderr     | 2 +-
 .../type-check/cannot_infer_local_or_vec_in_tuples.stderr     | 2 +-
 .../issue-116967-cannot-coerce-returned-result.stderr         | 2 +-
 tests/ui/type/type-check/issue-22897.stderr                   | 2 +-
 tests/ui/type/type-check/issue-40294.stderr                   | 2 +-
 tests/ui/type/type-check/issue-41314.stderr                   | 2 +-
 ...67273-assignment-match-prior-arm-bool-expected-unit.stderr | 2 +-
 ...issue-88577-check-fn-with-more-than-65535-arguments.stderr | 2 +-
 tests/ui/type/type-check/point-at-inference-3.stderr          | 2 +-
 .../ui/type/type-check/point-at-inference-issue-116155.stderr | 2 +-
 tests/ui/type/type-check/point-at-inference.stderr            | 2 +-
 tests/ui/type/type-dependent-def-issue-49241.stderr           | 2 +-
 tests/ui/type/type-error-break-tail.stderr                    | 2 +-
 tests/ui/type/type-parameter-defaults-referencing-Self.stderr | 2 +-
 tests/ui/type/type-parameter-names.stderr                     | 2 +-
 tests/ui/type/type-params-in-different-spaces-1.stderr        | 2 +-
 tests/ui/type/type-params-in-different-spaces-3.stderr        | 2 +-
 tests/ui/type/type-recursive-box-shadowed.stderr              | 2 +-
 tests/ui/type/type-shadow.stderr                              | 2 +-
 tests/ui/type/type-unsatisfiable.usage.stderr                 | 2 +-
 tests/ui/type_length_limit.stderr                             | 2 +-
 tests/ui/typeck/apit-with-error-type-in-sig.stderr            | 2 +-
 tests/ui/typeck/assign-non-lval-needs-deref.stderr            | 2 +-
 tests/ui/typeck/autoderef-with-param-env-error.stderr         | 2 +-
 tests/ui/typeck/bad-index-modulo-higher-ranked-regions.stderr | 2 +-
 tests/ui/typeck/bad-type-in-vec-contains.stderr               | 2 +-
 tests/ui/typeck/call-block.stderr                             | 2 +-
 tests/ui/typeck/check-args-on-fn-err.stderr                   | 2 +-
 tests/ui/typeck/derive-sugg-arg-arity.stderr                  | 2 +-
 .../dont-record-adjustments-when-pointing-at-arg.stderr       | 2 +-
 tests/ui/typeck/escaping_bound_vars.stderr                    | 2 +-
 tests/ui/typeck/issue-100246.stderr                           | 2 +-
 tests/ui/typeck/issue-100285.stderr                           | 2 +-
 tests/ui/typeck/issue-10401.stderr                            | 2 +-
 tests/ui/typeck/issue-104510-ice.stderr                       | 2 +-
 tests/ui/typeck/issue-106929.stderr                           | 2 +-
 tests/ui/typeck/issue-107087.stderr                           | 2 +-
 tests/ui/typeck/issue-107775.stderr                           | 2 +-
 tests/ui/typeck/issue-110052.stderr                           | 2 +-
 .../issue-112385-while-assign-lhs-place-expr-ice.stderr       | 2 +-
 tests/ui/typeck/issue-114918/const-in-fn-return-type.stderr   | 2 +-
 tests/ui/typeck/issue-114918/const-in-struct-type-arg.stderr  | 2 +-
 .../typeck/issue-114918/const-in-trait-fn-return-type.stderr  | 2 +-
 tests/ui/typeck/issue-13853-2.stderr                          | 2 +-
 tests/ui/typeck/issue-13853-5.stderr                          | 2 +-
 tests/ui/typeck/issue-1871.stderr                             | 2 +-
 tests/ui/typeck/issue-18937.stderr                            | 2 +-
 tests/ui/typeck/issue-33575.stderr                            | 2 +-
 tests/ui/typeck/issue-36708.stderr                            | 2 +-
 tests/ui/typeck/issue-43189.stderr                            | 2 +-
 tests/ui/typeck/issue-46112.stderr                            | 2 +-
 tests/ui/typeck/issue-50687-ice-on-borrow.stderr              | 2 +-
 tests/ui/typeck/issue-53712.stderr                            | 2 +-
 tests/ui/typeck/issue-57404.stderr                            | 2 +-
 .../ui/typeck/issue-57673-ice-on-deref-of-boxed-trait.stderr  | 2 +-
 ...issue-69378-ice-on-invalid-type-node-after-recovery.stderr | 2 +-
 tests/ui/typeck/issue-7813.stderr                             | 2 +-
 .../ui/typeck/issue-83621-placeholder-static-in-extern.stderr | 2 +-
 tests/ui/typeck/issue-84160.stderr                            | 2 +-
 tests/ui/typeck/issue-86721-return-expr-ice.rev1.stderr       | 2 +-
 tests/ui/typeck/issue-86721-return-expr-ice.rev2.stderr       | 2 +-
 tests/ui/typeck/issue-87181/empty-tuple-method.stderr         | 2 +-
 tests/ui/typeck/issue-87181/enum-variant.stderr               | 2 +-
 tests/ui/typeck/issue-87181/tuple-field.stderr                | 2 +-
 tests/ui/typeck/issue-87181/tuple-method.stderr               | 2 +-
 tests/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr  | 2 +-
 .../issue-87872-missing-inaccessible-field-literal.stderr     | 2 +-
 .../issue-87872-missing-inaccessible-field-pattern.stderr     | 2 +-
 tests/ui/typeck/issue-88803-call-expr-method.stderr           | 2 +-
 tests/ui/typeck/issue-88844.stderr                            | 2 +-
 tests/ui/typeck/issue-89044-wrapped-expr-method.stderr        | 2 +-
 tests/ui/typeck/issue-89275.stderr                            | 2 +-
 tests/ui/typeck/issue-89806.stderr                            | 2 +-
 tests/ui/typeck/issue-90101.stderr                            | 2 +-
 tests/ui/typeck/issue-90164.stderr                            | 2 +-
 tests/ui/typeck/issue-90319.stderr                            | 2 +-
 .../typeck/issue-90483-inaccessible-field-adjustment.stderr   | 2 +-
 .../typeck/issue-90804-incorrect-reference-suggestion.stderr  | 2 +-
 tests/ui/typeck/issue-91210-ptr-method.stderr                 | 2 +-
 tests/ui/typeck/issue-92481.stderr                            | 2 +-
 tests/ui/typeck/issue-93486.stderr                            | 2 +-
 tests/ui/typeck/issue-96530.stderr                            | 2 +-
 tests/ui/typeck/issue-98260.stderr                            | 2 +-
 tests/ui/typeck/issue-98982.stderr                            | 2 +-
 .../ui/typeck/missing-private-fields-in-struct-literal.stderr | 2 +-
 tests/ui/typeck/no-type-for-node-ice.stderr                   | 2 +-
 tests/ui/typeck/nonexistent-field-not-ambiguous.stderr        | 2 +-
 tests/ui/typeck/output-type-mismatch.stderr                   | 2 +-
 tests/ui/typeck/path-to-method-sugg-unresolved-expr.stderr    | 2 +-
 tests/ui/typeck/point-at-type-param-in-path-expr.stderr       | 2 +-
 tests/ui/typeck/point-at-type-parameter-definition.stderr     | 2 +-
 tests/ui/typeck/ptr-null-mutability-suggestions.stderr        | 2 +-
 tests/ui/typeck/quiet-type-err-let-binding.stderr             | 2 +-
 tests/ui/typeck/remove-extra-argument.stderr                  | 2 +-
 tests/ui/typeck/repeat-expr-checks-wf.stderr                  | 2 +-
 tests/ui/typeck/return-dyn-type-mismatch-2.stderr             | 2 +-
 tests/ui/typeck/return-dyn-type-mismatch.stderr               | 2 +-
 tests/ui/typeck/return_type_containing_closure.stderr         | 2 +-
 tests/ui/typeck/suppressed-error.stderr                       | 2 +-
 tests/ui/typeck/tag-that-dare-not-speak-its-name.stderr       | 2 +-
 tests/ui/typeck/terr-in-field.stderr                          | 2 +-
 tests/ui/typeck/terr-sorts.stderr                             | 2 +-
 tests/ui/typeck/typeck-cast-pointer-to-float.stderr           | 2 +-
 tests/ui/typeck/typeck-default-trait-impl-assoc-type.stderr   | 2 +-
 .../ui/typeck/typeck-default-trait-impl-negation-send.stderr  | 2 +-
 tests/ui/typeck/typeck-default-trait-impl-send-param.stderr   | 2 +-
 tests/ui/typeck/typeck_type_placeholder_lifetime_1.stderr     | 2 +-
 tests/ui/typeck/typeck_type_placeholder_lifetime_2.stderr     | 2 +-
 tests/ui/typeck/while-loop-block-cond.stderr                  | 2 +-
 tests/ui/typeck/while-type-error.stderr                       | 2 +-
 tests/ui/typeck/wrong-ret-type.stderr                         | 2 +-
 tests/ui/typeof/issue-100183.stderr                           | 2 +-
 tests/ui/typeof/issue-29184.stderr                            | 2 +-
 tests/ui/unboxed-closures/issue-30906.stderr                  | 2 +-
 tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr      | 2 +-
 tests/ui/unboxed-closures/non-tupled-call.stderr              | 2 +-
 tests/ui/unboxed-closures/unboxed-closure-feature-gate.stderr | 2 +-
 .../ui/unboxed-closures/unboxed-closure-no-cyclic-sig.stderr  | 2 +-
 tests/ui/unboxed-closures/unboxed-closure-region.stderr       | 2 +-
 .../ui/unboxed-closures/unboxed-closure-sugar-default.stderr  | 2 +-
 tests/ui/unboxed-closures/unboxed-closure-sugar-equiv.stderr  | 2 +-
 .../unboxed-closure-sugar-lifetime-elision.stderr             | 2 +-
 tests/ui/unboxed-closures/unboxed-closure-sugar-region.stderr | 2 +-
 .../unboxed-closure-sugar-used-on-struct-3.stderr             | 2 +-
 ...closure-sugar-wrong-number-number-type-parameters-1.stderr | 2 +-
 .../unboxed-closures/unboxed-closures-borrow-conflict.stderr  | 2 +-
 .../unboxed-closures-failed-recursive-fn-2.stderr             | 2 +-
 tests/ui/unboxed-closures/unboxed-closures-fnmut-as-fn.stderr | 2 +-
 ...d-closures-infer-argument-types-two-region-pointers.stderr | 2 +-
 ...unboxed-closures-infer-fn-once-move-from-projection.stderr | 2 +-
 .../unboxed-closures-infer-fnmut-missing-mut.stderr           | 2 +-
 .../unboxed-closures-infer-fnmut-move-missing-mut.stderr      | 2 +-
 .../unboxed-closures-infer-fnonce-call-twice.stderr           | 2 +-
 .../unboxed-closures-infer-fnonce-move-call-twice.stderr      | 2 +-
 .../unboxed-closures-mutated-upvar-from-fn-closure.stderr     | 2 +-
 .../unboxed-closures-recursive-fn-using-fn-mut.stderr         | 2 +-
 .../unboxed-closures-static-call-wrong-trait.stderr           | 2 +-
 tests/ui/unconstrained-none.stderr                            | 2 +-
 tests/ui/unconstrained-ref.stderr                             | 2 +-
 tests/ui/underscore-ident-matcher.stderr                      | 2 +-
 tests/ui/underscore-imports/shadow.stderr                     | 2 +-
 .../underscore-lifetime/dyn-trait-underscore-in-struct.stderr | 2 +-
 tests/ui/underscore-lifetime/dyn-trait-underscore.stderr      | 2 +-
 tests/ui/underscore-lifetime/in-fn-return-illegal.stderr      | 2 +-
 .../underscore-lifetime-elison-mismatch.stderr                | 2 +-
 .../ui/underscore-lifetime/underscore-outlives-bounds.stderr  | 2 +-
 .../where-clause-inherent-impl-ampersand-rust2015.stderr      | 2 +-
 .../where-clause-inherent-impl-ampersand-rust2018.stderr      | 2 +-
 .../where-clause-inherent-impl-underscore.rust2015.stderr     | 2 +-
 .../where-clause-inherent-impl-underscore.rust2018.stderr     | 2 +-
 .../where-clause-trait-impl-region-2015.stderr                | 2 +-
 .../where-clause-trait-impl-region-2018.stderr                | 2 +-
 .../where-clause-trait-impl-underscore.rust2015.stderr        | 2 +-
 .../where-clause-trait-impl-underscore.rust2018.stderr        | 2 +-
 tests/ui/unevaluated_fixed_size_array_len.stderr              | 2 +-
 tests/ui/uninhabited/privately-uninhabited-mir-call.stderr    | 2 +-
 tests/ui/uninhabited/uninhabited-irrefutable.stderr           | 2 +-
 tests/ui/union/issue-41073.stderr                             | 2 +-
 tests/ui/union/projection-as-union-type-error-2.stderr        | 2 +-
 tests/ui/union/projection-as-union-type-error.stderr          | 2 +-
 tests/ui/union/union-const-pat.stderr                         | 2 +-
 tests/ui/union/union-copy.stderr                              | 2 +-
 tests/ui/union/union-derive-eq.mirunsafeck.stderr             | 2 +-
 tests/ui/union/union-derive-eq.thirunsafeck.stderr            | 2 +-
 tests/ui/union/union-empty.stderr                             | 2 +-
 tests/ui/union/union-lint-dead-code.mirunsafeck.stderr        | 2 +-
 tests/ui/union/union-lint-dead-code.thirunsafeck.stderr       | 2 +-
 tests/ui/union/union-nonrepresentable.stderr                  | 2 +-
 tests/ui/union/union-repr-c.stderr                            | 2 +-
 tests/ui/union/unresolved-field-isnt-copy.stderr              | 2 +-
 tests/ui/unknown-language-item.stderr                         | 2 +-
 tests/ui/unknown-tool-name.stderr                             | 2 +-
 tests/ui/unop-neg-bool.stderr                                 | 2 +-
 tests/ui/unpretty/avoid-crash.stderr                          | 2 +-
 tests/ui/unpretty/bad-literal.stderr                          | 2 +-
 tests/ui/unpretty/mir-unpretty.stderr                         | 2 +-
 tests/ui/unresolved/unresolved-asterisk-imports.stderr        | 2 +-
 tests/ui/unresolved/unresolved-extern-mod-suggestion.stderr   | 2 +-
 tests/ui/unresolved/unresolved-import-recovery.stderr         | 2 +-
 .../unresolved-import-suggest-disambiguated-crate-name.stderr | 2 +-
 tests/ui/unsafe/foreign-unsafe-fn-called.mir.stderr           | 2 +-
 tests/ui/unsafe/foreign-unsafe-fn-called.thir.stderr          | 2 +-
 tests/ui/unsafe/initializing-ranged-via-ctor.stderr           | 2 +-
 tests/ui/unsafe/inline_asm.mir.stderr                         | 2 +-
 tests/ui/unsafe/inline_asm.thir.stderr                        | 2 +-
 ...115348-false-positive-warning-of-unnecessary-unsafe.stderr | 2 +-
 tests/ui/unsafe/issue-3080.mir.stderr                         | 2 +-
 tests/ui/unsafe/issue-3080.thir.stderr                        | 2 +-
 tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr                  | 2 +-
 tests/ui/unsafe/ranged_ints.mir.stderr                        | 2 +-
 tests/ui/unsafe/ranged_ints.thir.stderr                       | 2 +-
 tests/ui/unsafe/ranged_ints3.mirunsafeck.stderr               | 2 +-
 tests/ui/unsafe/ranged_ints3.thirunsafeck.stderr              | 2 +-
 tests/ui/unsafe/ranged_ints4.mirunsafeck.stderr               | 2 +-
 tests/ui/unsafe/ranged_ints4.thirunsafeck.stderr              | 2 +-
 tests/ui/unsafe/ranged_ints4_const.mirunsafeck.stderr         | 2 +-
 tests/ui/unsafe/ranged_ints4_const.thirunsafeck.stderr        | 2 +-
 tests/ui/unsafe/ranged_ints_const.mir.stderr                  | 2 +-
 tests/ui/unsafe/ranged_ints_const.thir.stderr                 | 2 +-
 tests/ui/unsafe/unsafe-assign.mirunsafeck.stderr              | 2 +-
 tests/ui/unsafe/unsafe-assign.thirunsafeck.stderr             | 2 +-
 tests/ui/unsafe/unsafe-block-without-braces.stderr            | 2 +-
 tests/ui/unsafe/unsafe-const-fn.mir.stderr                    | 2 +-
 tests/ui/unsafe/unsafe-const-fn.thir.stderr                   | 2 +-
 tests/ui/unsafe/unsafe-fn-assign-deref-ptr.mir.stderr         | 2 +-
 tests/ui/unsafe/unsafe-fn-assign-deref-ptr.thir.stderr        | 2 +-
 tests/ui/unsafe/unsafe-fn-autoderef.stderr                    | 2 +-
 tests/ui/unsafe/unsafe-fn-called-from-safe.mir.stderr         | 2 +-
 tests/ui/unsafe/unsafe-fn-called-from-safe.thir.stderr        | 2 +-
 tests/ui/unsafe/unsafe-fn-used-as-value.mir.stderr            | 2 +-
 tests/ui/unsafe/unsafe-fn-used-as-value.thir.stderr           | 2 +-
 tests/ui/unsafe/unsafe-subtyping.stderr                       | 2 +-
 tests/ui/unsafe/unsafe-trait-impl.stderr                      | 2 +-
 tests/ui/unsafe/unsafe-unstable-const-fn.mir.stderr           | 2 +-
 tests/ui/unsafe/unsafe-unstable-const-fn.thir.stderr          | 2 +-
 tests/ui/unsized-locals/by-value-trait-object-safety.stderr   | 2 +-
 tests/ui/unsized-locals/issue-30276-feature-flagged.stderr    | 2 +-
 tests/ui/unsized-locals/issue-30276.stderr                    | 2 +-
 tests/ui/unsized-locals/issue-50940-with-feature.stderr       | 2 +-
 tests/ui/unsized-locals/issue-50940.stderr                    | 2 +-
 tests/ui/unsized-locals/issue-67981.stderr                    | 2 +-
 tests/ui/unsized-locals/rust-call.stderr                      | 2 +-
 tests/ui/unsized-locals/unsized-exprs2.stderr                 | 2 +-
 tests/ui/unsized-locals/unsized-exprs3.stderr                 | 2 +-
 tests/ui/unsized/box-instead-of-dyn-fn.stderr                 | 2 +-
 tests/ui/unsized/issue-30355.stderr                           | 2 +-
 tests/ui/unsized/issue-71659.current.stderr                   | 2 +-
 tests/ui/unsized/issue-71659.next.stderr                      | 2 +-
 tests/ui/unsized/issue-75707.stderr                           | 2 +-
 tests/ui/unsized/issue-91801.stderr                           | 2 +-
 tests/ui/unsized/issue-91803.stderr                           | 2 +-
 tests/ui/unsized/param-mentioned-by-different-field.stderr    | 2 +-
 tests/ui/unsized/return-unsized-from-trait-method.stderr      | 2 +-
 tests/ui/unsized/unsized-bare-typaram.stderr                  | 2 +-
 tests/ui/unsized/unsized-enum.stderr                          | 2 +-
 tests/ui/unsized/unsized-fn-arg.stderr                        | 2 +-
 tests/ui/unsized/unsized-inherent-impl-self-type.stderr       | 2 +-
 tests/ui/unused-crate-deps/deny-attr.stderr                   | 2 +-
 tests/ui/unused-crate-deps/deny-cmdline.stderr                | 2 +-
 tests/ui/use/issue-18986.stderr                               | 2 +-
 tests/ui/use/use-after-move-based-on-type.stderr              | 2 +-
 tests/ui/use/use-after-move-implicity-coerced-object.stderr   | 2 +-
 tests/ui/use/use-after-move-self-based-on-type.stderr         | 2 +-
 tests/ui/use/use-after-move-self.stderr                       | 2 +-
 tests/ui/use/use-associated-const.stderr                      | 2 +-
 tests/ui/use/use-crate-self.stderr                            | 2 +-
 tests/ui/use/use-meta-mismatch.stderr                         | 2 +-
 tests/ui/use/use-mod/use-mod-5.stderr                         | 2 +-
 tests/ui/use/use-mod/use-mod-6.stderr                         | 2 +-
 tests/ui/use/use-nested-groups-error.stderr                   | 2 +-
 tests/ui/use/use-paths-as-items.stderr                        | 2 +-
 tests/ui/usize-generic-argument-parent.stderr                 | 2 +-
 tests/ui/variance/variance-associated-consts.stderr           | 2 +-
 tests/ui/variance/variance-associated-types2.stderr           | 2 +-
 tests/ui/variance/variance-cell-is-invariant.stderr           | 2 +-
 tests/ui/variance/variance-object-types.stderr                | 2 +-
 tests/ui/variance/variance-trait-matching.stderr              | 2 +-
 tests/ui/variance/variance-trait-object-bound.stderr          | 2 +-
 tests/ui/variance/variance-use-contravariant-struct-1.stderr  | 2 +-
 tests/ui/variance/variance-use-covariant-struct-1.stderr      | 2 +-
 tests/ui/variants/variant-size-differences.stderr             | 2 +-
 tests/ui/walk-struct-literal-with.stderr                      | 2 +-
 tests/ui/wf/issue-103573.stderr                               | 2 +-
 tests/ui/wf/issue-87495.stderr                                | 2 +-
 tests/ui/wf/issue-95665.stderr                                | 2 +-
 tests/ui/wf/issue-96810.stderr                                | 2 +-
 tests/ui/wf/wf-array-elem-sized.stderr                        | 2 +-
 tests/ui/wf/wf-complex-assoc-type.stderr                      | 2 +-
 tests/ui/wf/wf-enum-bound.stderr                              | 2 +-
 tests/ui/wf/wf-enum-fields-struct-variant.stderr              | 2 +-
 tests/ui/wf/wf-enum-fields.stderr                             | 2 +-
 tests/ui/wf/wf-impl-associated-type-region.stderr             | 2 +-
 tests/ui/wf/wf-impl-associated-type-trait.stderr              | 2 +-
 tests/ui/wf/wf-impl-self-type.stderr                          | 2 +-
 tests/ui/wf/wf-in-fn-arg.stderr                               | 2 +-
 tests/ui/wf/wf-in-fn-ret.stderr                               | 2 +-
 tests/ui/wf/wf-in-fn-type-arg.stderr                          | 2 +-
 tests/ui/wf/wf-in-fn-type-ret.stderr                          | 2 +-
 tests/ui/wf/wf-in-fn-where-clause.stderr                      | 2 +-
 tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr         | 2 +-
 tests/ui/wf/wf-in-obj-type-static.stderr                      | 2 +-
 tests/ui/wf/wf-in-obj-type-trait.stderr                       | 2 +-
 tests/ui/wf/wf-inherent-impl-method-where-clause.stderr       | 2 +-
 tests/ui/wf/wf-inherent-impl-where-clause.stderr              | 2 +-
 tests/ui/wf/wf-object-safe.stderr                             | 2 +-
 tests/ui/wf/wf-packed-on-proj-of-type-as-unimpl-trait.stderr  | 2 +-
 tests/ui/wf/wf-struct-bound.stderr                            | 2 +-
 tests/ui/wf/wf-struct-field.stderr                            | 2 +-
 tests/ui/wf/wf-trait-associated-type-bound.stderr             | 2 +-
 tests/ui/wf/wf-trait-associated-type-region.stderr            | 2 +-
 tests/ui/wf/wf-trait-associated-type-trait.stderr             | 2 +-
 tests/ui/wf/wf-trait-bound.stderr                             | 2 +-
 tests/ui/wf/wf-trait-default-fn-arg.stderr                    | 2 +-
 tests/ui/wf/wf-trait-default-fn-ret.stderr                    | 2 +-
 tests/ui/wf/wf-trait-default-fn-where-clause.stderr           | 2 +-
 tests/ui/wf/wf-trait-fn-arg.stderr                            | 2 +-
 tests/ui/wf/wf-trait-fn-ret.stderr                            | 2 +-
 tests/ui/wf/wf-trait-fn-where-clause.stderr                   | 2 +-
 tests/ui/wf/wf-trait-superbound.stderr                        | 2 +-
 tests/ui/where-clauses/higher-ranked-fn-type.quiet.stderr     | 2 +-
 tests/ui/where-clauses/higher-ranked-fn-type.verbose.stderr   | 2 +-
 tests/ui/where-clauses/ignore-err-clauses.stderr              | 2 +-
 tests/ui/where-clauses/self-in-where-clause-allowed.stderr    | 2 +-
 ...here-clause-constraints-are-local-for-inherent-impl.stderr | 2 +-
 .../where-clause-constraints-are-local-for-trait-impl.stderr  | 2 +-
 tests/ui/where-clauses/where-clause-method-substituion.stderr | 2 +-
 .../ui/where-clauses/where-clauses-method-unsatisfied.stderr  | 2 +-
 tests/ui/where-clauses/where-clauses-unsatisfied.stderr       | 2 +-
 tests/ui/where-clauses/where-for-self-2.stderr                | 2 +-
 tests/ui/where-clauses/where-for-self.stderr                  | 2 +-
 tests/ui/while/while-else-err.stderr                          | 2 +-
 tests/ui/while/while-else-let-else-err.stderr                 | 2 +-
 tests/ui/windows-subsystem-invalid.stderr                     | 2 +-
 tests/ui/writing-to-immutable-vec.stderr                      | 2 +-
 5025 files changed, 5026 insertions(+), 5026 deletions(-)

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 1cee57843f0..a3cda5aeab5 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -1465,7 +1465,7 @@ impl HandlerInner {
         };
         let errors = match self.deduplicated_err_count {
             0 => Cow::from(""),
-            1 => Cow::from("aborting due to previous error"),
+            1 => Cow::from("aborting due to 1 previous error"),
             count => Cow::from(format!("aborting due to {count} previous errors")),
         };
         if self.treat_err_as_bug() {
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index a9f67f984da..64feae0c6af 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1932,7 +1932,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// 8 |     foo::Foo {};
     ///   |     ^^^^^^^^ missing `you_can_use_this_field`
     ///
-    /// error: aborting due to previous error
+    /// error: aborting due to 1 previous error
     /// ```
     fn report_missing_fields(
         &self,
@@ -2049,7 +2049,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// 8 |     foo::Foo {};
     ///   |     ^^^^^^^^
     ///
-    /// error: aborting due to previous error
+    /// error: aborting due to 1 previous error
     /// ```
     fn report_private_fields(
         &self,
diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
index 0d8a306ace5..34a61e76fcf 100644
--- a/library/core/src/intrinsics/mir.rs
+++ b/library/core/src/intrinsics/mir.rs
@@ -193,7 +193,7 @@
 //! 27 | |     )
 //!    | |_____- binding declared here but left uninitialized
 //!
-//! error: aborting due to previous error
+//! error: aborting due to 1 previous error
 //!
 //! For more information about this error, try `rustc --explain E0381`.
 //! ```
diff --git a/tests/ui/abi/abi-typo-unstable.stderr b/tests/ui/abi/abi-typo-unstable.stderr
index 3b346e00227..d31cc2a896f 100644
--- a/tests/ui/abi/abi-typo-unstable.stderr
+++ b/tests/ui/abi/abi-typo-unstable.stderr
@@ -6,6 +6,6 @@ LL | extern "rust-intrinsec" fn rust_intrinsic() {}
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0703`.
diff --git a/tests/ui/alloc-error/alloc-error-handler-bad-signature-3.stderr b/tests/ui/alloc-error/alloc-error-handler-bad-signature-3.stderr
index eb739b149a1..3be219bdb06 100644
--- a/tests/ui/alloc-error/alloc-error-handler-bad-signature-3.stderr
+++ b/tests/ui/alloc-error/alloc-error-handler-bad-signature-3.stderr
@@ -16,6 +16,6 @@ LL | fn oom() -> ! {
    |    ^^^
    = note: this error originates in the attribute macro `alloc_error_handler` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/allocator/allocator-args.stderr b/tests/ui/allocator/allocator-args.stderr
index dfff2a7e709..ad640767fee 100644
--- a/tests/ui/allocator/allocator-args.stderr
+++ b/tests/ui/allocator/allocator-args.stderr
@@ -4,5 +4,5 @@ error: malformed `global_allocator` attribute input
 LL | #[global_allocator(malloc)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[global_allocator]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/allocator/function-allocator.stderr b/tests/ui/allocator/function-allocator.stderr
index 5e47b0f0cc7..3c0ba9580f7 100644
--- a/tests/ui/allocator/function-allocator.stderr
+++ b/tests/ui/allocator/function-allocator.stderr
@@ -4,5 +4,5 @@ error: allocators must be statics
 LL | fn foo() {}
    | ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/allocator/two-allocators.stderr b/tests/ui/allocator/two-allocators.stderr
index 7a914c2a390..1eecbc0a97b 100644
--- a/tests/ui/allocator/two-allocators.stderr
+++ b/tests/ui/allocator/two-allocators.stderr
@@ -10,5 +10,5 @@ LL | static B: System = System;
    |
    = note: this error originates in the attribute macro `global_allocator` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/allocator/two-allocators2.stderr b/tests/ui/allocator/two-allocators2.stderr
index b1fb4421ea0..f1e4b093cc6 100644
--- a/tests/ui/allocator/two-allocators2.stderr
+++ b/tests/ui/allocator/two-allocators2.stderr
@@ -1,4 +1,4 @@
 error: the `#[global_allocator]` in this crate conflicts with global allocator in: system_allocator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/allocator/two-allocators3.stderr b/tests/ui/allocator/two-allocators3.stderr
index a3079113d01..bf0f3a7c637 100644
--- a/tests/ui/allocator/two-allocators3.stderr
+++ b/tests/ui/allocator/two-allocators3.stderr
@@ -1,4 +1,4 @@
 error: the `#[global_allocator]` in system_allocator conflicts with global allocator in: system_allocator2
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/argument-suggestions/complex.stderr b/tests/ui/argument-suggestions/complex.stderr
index 205a852983a..bb3817421df 100644
--- a/tests/ui/argument-suggestions/complex.stderr
+++ b/tests/ui/argument-suggestions/complex.stderr
@@ -14,6 +14,6 @@ help: did you mean
 LL |   complex(/* u32 */, &"", /* E */, F::X2, G{}, X {}, Y {}, Z {});
    |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/argument-suggestions/display-is-suggestable.stderr b/tests/ui/argument-suggestions/display-is-suggestable.stderr
index edd72b53eb3..bde87475e0a 100644
--- a/tests/ui/argument-suggestions/display-is-suggestable.stderr
+++ b/tests/ui/argument-suggestions/display-is-suggestable.stderr
@@ -14,6 +14,6 @@ help: provide the argument
 LL |     foo(/* &dyn std::fmt::Display + Send */);
    |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/argument-suggestions/issue-112507.stderr b/tests/ui/argument-suggestions/issue-112507.stderr
index dfb47e010e4..17bde4d9743 100644
--- a/tests/ui/argument-suggestions/issue-112507.stderr
+++ b/tests/ui/argument-suggestions/issue-112507.stderr
@@ -22,6 +22,6 @@ LL ~         ,
 LL ~         None);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/argument-suggestions/issue-96638.stderr b/tests/ui/argument-suggestions/issue-96638.stderr
index 4d18b97c98b..887bf82a2f6 100644
--- a/tests/ui/argument-suggestions/issue-96638.stderr
+++ b/tests/ui/argument-suggestions/issue-96638.stderr
@@ -16,6 +16,6 @@ help: provide the argument
 LL |     f(/* usize */, &x, /* usize */);
    |      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/argument-suggestions/issue-97197.stderr b/tests/ui/argument-suggestions/issue-97197.stderr
index de221ba1fe1..3768367a5e6 100644
--- a/tests/ui/argument-suggestions/issue-97197.stderr
+++ b/tests/ui/argument-suggestions/issue-97197.stderr
@@ -14,6 +14,6 @@ help: provide the arguments
 LL |     g((), /* bool */, /* bool */, /* bool */, /* bool */, ());
    |      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/argument-suggestions/issue-97484.stderr b/tests/ui/argument-suggestions/issue-97484.stderr
index 082564fbc7f..6bdb734fddf 100644
--- a/tests/ui/argument-suggestions/issue-97484.stderr
+++ b/tests/ui/argument-suggestions/issue-97484.stderr
@@ -23,6 +23,6 @@ LL -     foo(&&A, B, C, D, E, F, G);
 LL +     foo(&&A, D, /* &E */, G);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/argument-suggestions/issue-98894.stderr b/tests/ui/argument-suggestions/issue-98894.stderr
index f64a83ab710..72e6fec27e6 100644
--- a/tests/ui/argument-suggestions/issue-98894.stderr
+++ b/tests/ui/argument-suggestions/issue-98894.stderr
@@ -14,6 +14,6 @@ help: provide the argument
 LL |     (|_, ()| ())(if true {} else {return;}, ());
    |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0057`.
diff --git a/tests/ui/argument-suggestions/issue-98897.stderr b/tests/ui/argument-suggestions/issue-98897.stderr
index f2c47d353ef..eed3964559a 100644
--- a/tests/ui/argument-suggestions/issue-98897.stderr
+++ b/tests/ui/argument-suggestions/issue-98897.stderr
@@ -14,6 +14,6 @@ help: provide the argument
 LL |     (|_, ()| ())([return, ()], ());
    |                 ~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0057`.
diff --git a/tests/ui/argument-suggestions/issue-99482.stderr b/tests/ui/argument-suggestions/issue-99482.stderr
index bcf36e37cdc..9c83b47f8b6 100644
--- a/tests/ui/argument-suggestions/issue-99482.stderr
+++ b/tests/ui/argument-suggestions/issue-99482.stderr
@@ -14,6 +14,6 @@ help: provide the argument
 LL |     let _f = f((), main);
    |               ~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0057`.
diff --git a/tests/ui/argument-suggestions/too-long.stderr b/tests/ui/argument-suggestions/too-long.stderr
index bb6f06a35c6..04ee9275cb3 100644
--- a/tests/ui/argument-suggestions/too-long.stderr
+++ b/tests/ui/argument-suggestions/too-long.stderr
@@ -19,6 +19,6 @@ help: consider dereferencing the borrow
 LL |     qux.foo(a, b, c, d, e, *f, g, h, i, j, k, l);
    |                            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/argument-suggestions/two-mismatch-notes.stderr b/tests/ui/argument-suggestions/two-mismatch-notes.stderr
index 70cc60255c7..65b3d285100 100644
--- a/tests/ui/argument-suggestions/two-mismatch-notes.stderr
+++ b/tests/ui/argument-suggestions/two-mismatch-notes.stderr
@@ -24,6 +24,6 @@ note: function defined here
 LL | fn foo(_: fn(i32), _: Wrapper<i32>) {}
    |    ^^^ ----------  ---------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/array-slice-vec/array_const_index-0.stderr b/tests/ui/array-slice-vec/array_const_index-0.stderr
index 3b92cc76687..d16e8d50dfd 100644
--- a/tests/ui/array-slice-vec/array_const_index-0.stderr
+++ b/tests/ui/array-slice-vec/array_const_index-0.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const B: i32 = (&A)[1];
    |                ^^^^^^^ index out of bounds: the length is 0 but the index is 1
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/array-slice-vec/array_const_index-1.stderr b/tests/ui/array-slice-vec/array_const_index-1.stderr
index 591db268a99..f9ba2f13911 100644
--- a/tests/ui/array-slice-vec/array_const_index-1.stderr
+++ b/tests/ui/array-slice-vec/array_const_index-1.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const B: i32 = A[1];
    |                ^^^^ index out of bounds: the length is 0 but the index is 1
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/array-slice-vec/match_arr_unknown_len.stderr b/tests/ui/array-slice-vec/match_arr_unknown_len.stderr
index 5e531a993c6..3ed0d6bdf3a 100644
--- a/tests/ui/array-slice-vec/match_arr_unknown_len.stderr
+++ b/tests/ui/array-slice-vec/match_arr_unknown_len.stderr
@@ -7,6 +7,6 @@ LL |         [1, 2] => true,
    = note: expected array `[u32; 2]`
               found array `[u32; N]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/array-slice-vec/slice-mut-2.stderr b/tests/ui/array-slice-vec/slice-mut-2.stderr
index c33919c41cd..8cc2c6e0397 100644
--- a/tests/ui/array-slice-vec/slice-mut-2.stderr
+++ b/tests/ui/array-slice-vec/slice-mut-2.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     let x: &[isize] = &mut [1, 2, 3, 4, 5];
    |                        +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/array-slice-vec/slice-mut.stderr b/tests/ui/array-slice-vec/slice-mut.stderr
index 7d34defc1d5..288031e505c 100644
--- a/tests/ui/array-slice-vec/slice-mut.stderr
+++ b/tests/ui/array-slice-vec/slice-mut.stderr
@@ -9,6 +9,6 @@ LL |     let y: &mut[_] = &x[2..4];
    = note: expected mutable reference `&mut [_]`
                       found reference `&[isize]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/array-slice-vec/slice-to-vec-comparison.stderr b/tests/ui/array-slice-vec/slice-to-vec-comparison.stderr
index 47008e1d999..7e5b8afea24 100644
--- a/tests/ui/array-slice-vec/slice-to-vec-comparison.stderr
+++ b/tests/ui/array-slice-vec/slice-to-vec-comparison.stderr
@@ -7,6 +7,6 @@ LL |     a > b;
    = note: expected reference `&[_; 0]`
               found reference `&Vec<u8>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/array-slice-vec/vec-macro-with-comma-only.stderr b/tests/ui/array-slice-vec/vec-macro-with-comma-only.stderr
index ec4a001f4d0..b3f953af6d2 100644
--- a/tests/ui/array-slice-vec/vec-macro-with-comma-only.stderr
+++ b/tests/ui/array-slice-vec/vec-macro-with-comma-only.stderr
@@ -6,5 +6,5 @@ LL |     vec![,];
    |
    = note: while trying to match end of macro
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/array-slice-vec/vec-mut-iter-borrow.stderr b/tests/ui/array-slice-vec/vec-mut-iter-borrow.stderr
index 679fd899773..d9343140fb1 100644
--- a/tests/ui/array-slice-vec/vec-mut-iter-borrow.stderr
+++ b/tests/ui/array-slice-vec/vec-mut-iter-borrow.stderr
@@ -9,6 +9,6 @@ LL |     for x in &mut xs {
 LL |         xs.push(1)
    |         ^^ second mutable borrow occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/array-slice-vec/vec-res-add.stderr b/tests/ui/array-slice-vec/vec-res-add.stderr
index 7511271361d..cf5796f7e4a 100644
--- a/tests/ui/array-slice-vec/vec-res-add.stderr
+++ b/tests/ui/array-slice-vec/vec-res-add.stderr
@@ -6,6 +6,6 @@ LL |     let k = i + j;
    |             |
    |             Vec<R>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/array-slice-vec/vector-no-ann.stderr b/tests/ui/array-slice-vec/vector-no-ann.stderr
index 619417a73c9..24b6abfb342 100644
--- a/tests/ui/array-slice-vec/vector-no-ann.stderr
+++ b/tests/ui/array-slice-vec/vector-no-ann.stderr
@@ -9,6 +9,6 @@ help: consider giving `_foo` an explicit type, where the type for type parameter
 LL |     let _foo: Vec<T> = Vec::new();
    |             ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/asm/issue-113788.stderr b/tests/ui/asm/issue-113788.stderr
index f8e65b6f538..c44ba3c91d9 100644
--- a/tests/ui/asm/issue-113788.stderr
+++ b/tests/ui/asm/issue-113788.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `PEB` in this scope
 LL |     let peb: *const PEB;
    |                     ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/asm/issue-72570.stderr b/tests/ui/asm/issue-72570.stderr
index 49013a23ced..13f39e7def9 100644
--- a/tests/ui/asm/issue-72570.stderr
+++ b/tests/ui/asm/issue-72570.stderr
@@ -4,5 +4,5 @@ error: invalid register `invalid`: unknown register
 LL |         asm!("", in("invalid") "".len());
    |                  ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/asm/issue-85247.rwpi.stderr b/tests/ui/asm/issue-85247.rwpi.stderr
index 996b0933a34..8466a53be29 100644
--- a/tests/ui/asm/issue-85247.rwpi.stderr
+++ b/tests/ui/asm/issue-85247.rwpi.stderr
@@ -4,5 +4,5 @@ error: cannot use register `r9`: the RWPI static base register (r9) cannot be us
 LL |         asm!("", out("r9") _);
    |                  ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/asm/issue-87802.stderr b/tests/ui/asm/issue-87802.stderr
index de3e28fdd12..762f3d02a41 100644
--- a/tests/ui/asm/issue-87802.stderr
+++ b/tests/ui/asm/issue-87802.stderr
@@ -6,5 +6,5 @@ LL |         asm!("/* {0} */", out(reg) x);
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/asm/issue-99071.stderr b/tests/ui/asm/issue-99071.stderr
index 47386ffa4a8..1703d2977a7 100644
--- a/tests/ui/asm/issue-99071.stderr
+++ b/tests/ui/asm/issue-99071.stderr
@@ -4,5 +4,5 @@ error: cannot use register `r8`: high registers (r8+) can only be used as clobbe
 LL |         asm!("", in("r8") 0);
    |                  ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/asm/issue-99122.stderr b/tests/ui/asm/issue-99122.stderr
index 2758a4ac437..2767a6d54ed 100644
--- a/tests/ui/asm/issue-99122.stderr
+++ b/tests/ui/asm/issue-99122.stderr
@@ -6,6 +6,6 @@ LL |     let pointer = 1u32 as *const _;
    |
    = note: the type information given here is insufficient to check whether the pointer cast is valid
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0641`.
diff --git a/tests/ui/asm/reg-conflict.stderr b/tests/ui/asm/reg-conflict.stderr
index 2395566de39..a4dd8e0a959 100644
--- a/tests/ui/asm/reg-conflict.stderr
+++ b/tests/ui/asm/reg-conflict.stderr
@@ -6,5 +6,5 @@ LL |         asm!("", out("d0") _, out("s1") _);
    |                  |
    |                  register `d0`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/assign-imm-local-twice.stderr b/tests/ui/assign-imm-local-twice.stderr
index bba5d8dffe4..d92485de68f 100644
--- a/tests/ui/assign-imm-local-twice.stderr
+++ b/tests/ui/assign-imm-local-twice.stderr
@@ -10,6 +10,6 @@ LL |     println!("v={}", v);
 LL |     v = 2;
    |     ^^^^^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/associated-consts/associated-const-ambiguity-report.stderr b/tests/ui/associated-consts/associated-const-ambiguity-report.stderr
index e39224f2c16..42d722291c3 100644
--- a/tests/ui/associated-consts/associated-const-ambiguity-report.stderr
+++ b/tests/ui/associated-consts/associated-const-ambiguity-report.stderr
@@ -21,6 +21,6 @@ LL | const X: i32 = <i32 as Bar>::ID;
 LL | const X: i32 = <i32 as Foo>::ID;
    |                ~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/associated-consts/associated-const-array-len.stderr b/tests/ui/associated-consts/associated-const-array-len.stderr
index e3db45810fd..f804cf20591 100644
--- a/tests/ui/associated-consts/associated-const-array-len.stderr
+++ b/tests/ui/associated-consts/associated-const-array-len.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Foo {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-consts/associated-const-dead-code.stderr b/tests/ui/associated-consts/associated-const-dead-code.stderr
index 7e485a314c5..33f5a5ceedf 100644
--- a/tests/ui/associated-consts/associated-const-dead-code.stderr
+++ b/tests/ui/associated-consts/associated-const-dead-code.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-consts/associated-const-generic-obligations.stderr b/tests/ui/associated-consts/associated-const-generic-obligations.stderr
index d45868151b1..5ea85ff3b98 100644
--- a/tests/ui/associated-consts/associated-const-generic-obligations.stderr
+++ b/tests/ui/associated-consts/associated-const-generic-obligations.stderr
@@ -12,6 +12,6 @@ LL |     const FROM: Self::Out;
    = note: expected associated type `<T as Foo>::Out`
                     found reference `&'static str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0326`.
diff --git a/tests/ui/associated-consts/associated-const-impl-wrong-lifetime.stderr b/tests/ui/associated-consts/associated-const-impl-wrong-lifetime.stderr
index 742b81535df..6037122a365 100644
--- a/tests/ui/associated-consts/associated-const-impl-wrong-lifetime.stderr
+++ b/tests/ui/associated-consts/associated-const-impl-wrong-lifetime.stderr
@@ -13,6 +13,6 @@ LL | impl<'a> Foo for &'a () {
    |      ^^
    = note: ...does not necessarily outlive the static lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-consts/associated-const-impl-wrong-type.stderr b/tests/ui/associated-consts/associated-const-impl-wrong-type.stderr
index f3616035fc7..b91b777d585 100644
--- a/tests/ui/associated-consts/associated-const-impl-wrong-type.stderr
+++ b/tests/ui/associated-consts/associated-const-impl-wrong-type.stderr
@@ -10,6 +10,6 @@ note: type in trait
 LL |     const BAR: u32;
    |                ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0326`.
diff --git a/tests/ui/associated-consts/associated-const-in-trait.stderr b/tests/ui/associated-consts/associated-const-in-trait.stderr
index 60bbe385c01..59acd4820ae 100644
--- a/tests/ui/associated-consts/associated-const-in-trait.stderr
+++ b/tests/ui/associated-consts/associated-const-in-trait.stderr
@@ -13,6 +13,6 @@ LL |     const N: usize;
    |           ^ ...because it contains this associated `const`
    = help: consider moving `N` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/associated-consts/associated-const-no-item.stderr b/tests/ui/associated-consts/associated-const-no-item.stderr
index fe27da5ac64..7ded05b7b48 100644
--- a/tests/ui/associated-consts/associated-const-no-item.stderr
+++ b/tests/ui/associated-consts/associated-const-no-item.stderr
@@ -11,6 +11,6 @@ note: `Foo` defines an item `ID`, perhaps you need to implement it
 LL | trait Foo {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/associated-consts/associated-const-private-impl.stderr b/tests/ui/associated-consts/associated-const-private-impl.stderr
index a3fa3002e1e..13bde56a680 100644
--- a/tests/ui/associated-consts/associated-const-private-impl.stderr
+++ b/tests/ui/associated-consts/associated-const-private-impl.stderr
@@ -7,6 +7,6 @@ LL |             const ID: i32 = 1;
 LL |     assert_eq!(1, bar1::Foo::ID);
    |                              ^^ private associated constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/associated-consts/associated-const-type-parameter-arrays-2.stderr b/tests/ui/associated-consts/associated-const-type-parameter-arrays-2.stderr
index 0bc019b2dc8..cd830394285 100644
--- a/tests/ui/associated-consts/associated-const-type-parameter-arrays-2.stderr
+++ b/tests/ui/associated-consts/associated-const-type-parameter-arrays-2.stderr
@@ -6,5 +6,5 @@ LL |     let _array = [4; <A as Foo>::Y];
    |
    = note: this may fail depending on what value the parameter takes
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-consts/associated-const-type-parameter-arrays.stderr b/tests/ui/associated-consts/associated-const-type-parameter-arrays.stderr
index 46a54a12d62..3234945e0df 100644
--- a/tests/ui/associated-consts/associated-const-type-parameter-arrays.stderr
+++ b/tests/ui/associated-consts/associated-const-type-parameter-arrays.stderr
@@ -7,5 +7,5 @@ LL |     let _array: [u32; <A as Foo>::Y];
    = note: type parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-consts/defaults-cyclic-fail.stderr b/tests/ui/associated-consts/defaults-cyclic-fail.stderr
index e29c32f5dfd..9cee03041fe 100644
--- a/tests/ui/associated-consts/defaults-cyclic-fail.stderr
+++ b/tests/ui/associated-consts/defaults-cyclic-fail.stderr
@@ -27,6 +27,6 @@ LL |     assert_eq!(<() as Tr>::A, 0);
    |                ^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-consts/defaults-not-assumed-fail.stderr b/tests/ui/associated-consts/defaults-not-assumed-fail.stderr
index ac5ec8e05ea..091a50f9463 100644
--- a/tests/ui/associated-consts/defaults-not-assumed-fail.stderr
+++ b/tests/ui/associated-consts/defaults-not-assumed-fail.stderr
@@ -27,6 +27,6 @@ LL |     assert_eq!(<() as Tr>::B, 0);    // causes the error above
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
    = note: this note originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/associated-consts/double-elided.stderr b/tests/ui/associated-consts/double-elided.stderr
index ba4e6a23e27..67834788ccd 100644
--- a/tests/ui/associated-consts/double-elided.stderr
+++ b/tests/ui/associated-consts/double-elided.stderr
@@ -42,6 +42,6 @@ note: but the referenced data is only valid for the anonymous lifetime as define
 LL |     const C: &&str = &"";
    |              ^
 
-error: aborting due to previous error; 2 warnings emitted
+error: aborting due to 1 previous error; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/associated-consts/infer-placeholder-in-non-suggestable-pos.stderr b/tests/ui/associated-consts/infer-placeholder-in-non-suggestable-pos.stderr
index f8c02420f96..e946491a084 100644
--- a/tests/ui/associated-consts/infer-placeholder-in-non-suggestable-pos.stderr
+++ b/tests/ui/associated-consts/infer-placeholder-in-non-suggestable-pos.stderr
@@ -18,6 +18,6 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL |     const ASSOC: &dyn Fn(_) = 1i32;
    |                          ^ not allowed in type signatures
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/associated-consts/issue-102335-const.stderr b/tests/ui/associated-consts/issue-102335-const.stderr
index 531d15c5900..b69dfd51ea8 100644
--- a/tests/ui/associated-consts/issue-102335-const.stderr
+++ b/tests/ui/associated-consts/issue-102335-const.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     type A: S<C<X = 0i32> = 34>;
    |                 ^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-impl.stderr b/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-impl.stderr
index 4418fb7556b..21062fdaf58 100644
--- a/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-impl.stderr
+++ b/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-impl.stderr
@@ -38,6 +38,6 @@ LL |     const BAR: u32 = IMPL_REF_BAR;
    = note: cycle used when running analysis passes on this crate
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait-default.stderr b/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait-default.stderr
index 392cd5e3443..e4abf6203e8 100644
--- a/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait-default.stderr
+++ b/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait-default.stderr
@@ -38,6 +38,6 @@ LL |     const BAR: u32 = DEFAULT_REF_BAR;
    = note: cycle used when running analysis passes on this crate
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait.stderr b/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait.stderr
index 6cbddca9c62..05ebd76f500 100644
--- a/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait.stderr
+++ b/tests/ui/associated-consts/issue-24949-assoc-const-static-recursion-trait.stderr
@@ -38,6 +38,6 @@ LL |     const BAR: u32 = TRAIT_REF_BAR;
    = note: cycle used when running analysis passes on this crate
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-consts/issue-47814.stderr b/tests/ui/associated-consts/issue-47814.stderr
index 2e4ddb81166..7382426b0ff 100644
--- a/tests/ui/associated-consts/issue-47814.stderr
+++ b/tests/ui/associated-consts/issue-47814.stderr
@@ -10,5 +10,5 @@ note: not a concrete type
 LL | impl<'a> ArpIPv4<'a> {
    |          ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-consts/projection-unspecified-but-bounded.stderr b/tests/ui/associated-consts/projection-unspecified-but-bounded.stderr
index 8175e510a09..91bfcf29cb3 100644
--- a/tests/ui/associated-consts/projection-unspecified-but-bounded.stderr
+++ b/tests/ui/associated-consts/projection-unspecified-but-bounded.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `foo`
 LL | fn foo<T: TraitWAssocConst<A = 32>>() {}
    |                            ^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-consts/shadowed-const.stderr b/tests/ui/associated-consts/shadowed-const.stderr
index fe21d2aec00..a01a9ae561f 100644
--- a/tests/ui/associated-consts/shadowed-const.stderr
+++ b/tests/ui/associated-consts/shadowed-const.stderr
@@ -4,5 +4,5 @@ error: found associated const `BAR` when type was expected
 LL |   const QUX: Self::BAR;
    |              ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/ambiguity.stderr b/tests/ui/associated-inherent-types/ambiguity.stderr
index 155c296cbb3..09e6c139703 100644
--- a/tests/ui/associated-inherent-types/ambiguity.stderr
+++ b/tests/ui/associated-inherent-types/ambiguity.stderr
@@ -15,6 +15,6 @@ note: candidate #2 is defined in an impl for the type `Wrapper<()>`
 LL |     type Foo = ();
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/associated-inherent-types/assoc-inherent-no-body.stderr b/tests/ui/associated-inherent-types/assoc-inherent-no-body.stderr
index 387a5658da3..c332416c6f3 100644
--- a/tests/ui/associated-inherent-types/assoc-inherent-no-body.stderr
+++ b/tests/ui/associated-inherent-types/assoc-inherent-no-body.stderr
@@ -6,5 +6,5 @@ LL |     type Baz;
    |             |
    |             help: provide a definition for the type: `= <type>;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/assoc-inherent-unstable.stderr b/tests/ui/associated-inherent-types/assoc-inherent-unstable.stderr
index 415ee0193c9..cf2aee6ab53 100644
--- a/tests/ui/associated-inherent-types/assoc-inherent-unstable.stderr
+++ b/tests/ui/associated-inherent-types/assoc-inherent-unstable.stderr
@@ -6,6 +6,6 @@ LL | type Data = aux::Owner::Data;
    |
    = help: add `#![feature(data)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr b/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr
index 3c373f139cb..a2ad4cbde01 100644
--- a/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr
+++ b/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr
@@ -39,6 +39,6 @@ LL | | fn main() {}
    | |____________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-where-predicate.stderr b/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-where-predicate.stderr
index ab6a97b3d85..b3d55fea14b 100644
--- a/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-where-predicate.stderr
+++ b/tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-where-predicate.stderr
@@ -33,6 +33,6 @@ LL | | fn main() {}
    | |____________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-inherent-types/generic-associated-types-bad.local.stderr b/tests/ui/associated-inherent-types/generic-associated-types-bad.local.stderr
index fcf828c21c7..58598340538 100644
--- a/tests/ui/associated-inherent-types/generic-associated-types-bad.local.stderr
+++ b/tests/ui/associated-inherent-types/generic-associated-types-bad.local.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Ty::Pr`
 LL |     type Pr<T: Copy> = T;
    |                ^^^^ required by this bound in `Ty::Pr`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-inherent-types/generic-associated-types-bad.region.stderr b/tests/ui/associated-inherent-types/generic-associated-types-bad.region.stderr
index 94c20521857..1be65687a3e 100644
--- a/tests/ui/associated-inherent-types/generic-associated-types-bad.region.stderr
+++ b/tests/ui/associated-inherent-types/generic-associated-types-bad.region.stderr
@@ -7,5 +7,5 @@ LL |     #[cfg(region)]
 LL |     let _: Ty::Static<&'a str> = "";
    |            ^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/inference-fail.stderr b/tests/ui/associated-inherent-types/inference-fail.stderr
index f29144e4aa7..bf329c69e99 100644
--- a/tests/ui/associated-inherent-types/inference-fail.stderr
+++ b/tests/ui/associated-inherent-types/inference-fail.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     let _: S<_>::P = ();
    |            ^^^^^^^ cannot infer type for type parameter `T`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/associated-inherent-types/issue-109299-1.stderr b/tests/ui/associated-inherent-types/issue-109299-1.stderr
index dc59b56ee20..c25ffb9d9c2 100644
--- a/tests/ui/associated-inherent-types/issue-109299-1.stderr
+++ b/tests/ui/associated-inherent-types/issue-109299-1.stderr
@@ -10,6 +10,6 @@ LL | type X = impl for<T> Fn() -> Lexer<T>::Cursor;
    = note: the associated type was found for
            - `Lexer<i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/ui/associated-inherent-types/issue-109299.stderr b/tests/ui/associated-inherent-types/issue-109299.stderr
index 63f50732d3c..1e11c0e8c2a 100644
--- a/tests/ui/associated-inherent-types/issue-109299.stderr
+++ b/tests/ui/associated-inherent-types/issue-109299.stderr
@@ -6,6 +6,6 @@ LL | impl Lexer<'d> {
    |     |
    |     help: consider introducing lifetime `'d` here: `<'d>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0261`.
diff --git a/tests/ui/associated-inherent-types/issue-111404-1.stderr b/tests/ui/associated-inherent-types/issue-111404-1.stderr
index c55f1432389..2c78e3a1fb7 100644
--- a/tests/ui/associated-inherent-types/issue-111404-1.stderr
+++ b/tests/ui/associated-inherent-types/issue-111404-1.stderr
@@ -4,5 +4,5 @@ error: higher-ranked subtype error
 LL | fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/issue-111879-0.stderr b/tests/ui/associated-inherent-types/issue-111879-0.stderr
index f6367c88aea..f60fd58c23b 100644
--- a/tests/ui/associated-inherent-types/issue-111879-0.stderr
+++ b/tests/ui/associated-inherent-types/issue-111879-0.stderr
@@ -4,5 +4,5 @@ error: overflow evaluating associated type `Carrier<'b>::Focus<i32>`
 LL |     pub type Focus<T> = &'a mut for<'b> fn(Carrier<'b>::Focus<i32>);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/issue-111879-1.stderr b/tests/ui/associated-inherent-types/issue-111879-1.stderr
index bf35f2bb5b5..eb3329dc5e9 100644
--- a/tests/ui/associated-inherent-types/issue-111879-1.stderr
+++ b/tests/ui/associated-inherent-types/issue-111879-1.stderr
@@ -7,6 +7,6 @@ LL | fn main(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
    = note: expected signature `fn()`
               found signature `fn(for<'a> fn(&'a ()))`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0580`.
diff --git a/tests/ui/associated-inherent-types/late-bound-regions.stderr b/tests/ui/associated-inherent-types/late-bound-regions.stderr
index 0dd17b05cd0..fba3a5b8533 100644
--- a/tests/ui/associated-inherent-types/late-bound-regions.stderr
+++ b/tests/ui/associated-inherent-types/late-bound-regions.stderr
@@ -7,6 +7,6 @@ LL |     f(&local)
    |     | `local` is borrowed here
    |     returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/associated-inherent-types/normalization-overflow.stderr b/tests/ui/associated-inherent-types/normalization-overflow.stderr
index 16bb64281e3..7f991a53c9b 100644
--- a/tests/ui/associated-inherent-types/normalization-overflow.stderr
+++ b/tests/ui/associated-inherent-types/normalization-overflow.stderr
@@ -4,5 +4,5 @@ error: overflow evaluating associated type `T::This`
 LL |     type This = Self::This;
    |                 ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.shadowed.stderr b/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.shadowed.stderr
index 3561db354c0..9bd5a842fdc 100644
--- a/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.shadowed.stderr
+++ b/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.shadowed.stderr
@@ -10,6 +10,6 @@ LL |     let _: S::<bool>::Pr = ();
    = note: the associated type was found for
            - `S<()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.uncovered.stderr b/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.uncovered.stderr
index 9206b4f6db7..978305c2ce3 100644
--- a/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.uncovered.stderr
+++ b/tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.uncovered.stderr
@@ -4,6 +4,6 @@ error[E0223]: ambiguous associated type
 LL |     let _: S::<bool>::Pr = ();
    |            ^^^^^^^^^^^^^ help: use fully-qualified syntax: `<S<bool> as Tr>::Pr`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-1.stderr b/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-1.stderr
index 230bfa538b4..0d5f781dc63 100644
--- a/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-1.stderr
+++ b/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-1.stderr
@@ -10,5 +10,5 @@ LL | struct Container<T>(T);
    = note: the following trait bounds were not satisfied:
            `T: Clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-in-multiple-impls.stderr b/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-in-multiple-impls.stderr
index 3ddab25deb5..650b5946064 100644
--- a/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-in-multiple-impls.stderr
+++ b/tests/ui/associated-inherent-types/not-found-unsatisfied-bounds-in-multiple-impls.stderr
@@ -16,5 +16,5 @@ LL |     let _: S::<Featureless, Featureless>::X;
            `Featureless: One`
            `Featureless: Two`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/regionck-0.stderr b/tests/ui/associated-inherent-types/regionck-0.stderr
index 3a438ee630e..32e6d8e465a 100644
--- a/tests/ui/associated-inherent-types/regionck-0.stderr
+++ b/tests/ui/associated-inherent-types/regionck-0.stderr
@@ -6,5 +6,5 @@ LL | fn user<'a>() {
 LL |     let _: S::<&'a ()>::T;
    |            ^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/regionck-2.stderr b/tests/ui/associated-inherent-types/regionck-2.stderr
index b0a4ed35d56..4c68a591240 100644
--- a/tests/ui/associated-inherent-types/regionck-2.stderr
+++ b/tests/ui/associated-inherent-types/regionck-2.stderr
@@ -13,6 +13,6 @@ LL | fn test(_: Lexer::Cursor) {}
    |            ^^^^^
    = note: ...does not necessarily outlive the static lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-inherent-types/style.stderr b/tests/ui/associated-inherent-types/style.stderr
index f83061f8c42..12e4d545ab1 100644
--- a/tests/ui/associated-inherent-types/style.stderr
+++ b/tests/ui/associated-inherent-types/style.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_camel_case_types)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-inherent-types/unsatisfied-bounds-inferred-type.stderr b/tests/ui/associated-inherent-types/unsatisfied-bounds-inferred-type.stderr
index ecf30f4cdec..7ce69a94bf8 100644
--- a/tests/ui/associated-inherent-types/unsatisfied-bounds-inferred-type.stderr
+++ b/tests/ui/associated-inherent-types/unsatisfied-bounds-inferred-type.stderr
@@ -12,6 +12,6 @@ LL | impl<T: Copy> S<T> {
 LL |     type T = T;
    |          - required by a bound in this associated type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-inherent-types/unsatisfied-bounds-where-clause-on-assoc-ty.stderr b/tests/ui/associated-inherent-types/unsatisfied-bounds-where-clause-on-assoc-ty.stderr
index d4968cd05dc..cb35cdde0b4 100644
--- a/tests/ui/associated-inherent-types/unsatisfied-bounds-where-clause-on-assoc-ty.stderr
+++ b/tests/ui/associated-inherent-types/unsatisfied-bounds-where-clause-on-assoc-ty.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         T: Copy;
    |            ^^^^ required by this bound in `S<T>::X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-item/ambiguous-associated-type-with-generics.stderr b/tests/ui/associated-item/ambiguous-associated-type-with-generics.stderr
index f7a47be8dc3..9e1dd739807 100644
--- a/tests/ui/associated-item/ambiguous-associated-type-with-generics.stderr
+++ b/tests/ui/associated-item/ambiguous-associated-type-with-generics.stderr
@@ -4,6 +4,6 @@ error[E0223]: ambiguous associated type
 LL |     let _x: <dyn Trait<i32>>::Ty;
    |             ^^^^^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: `<dyn Trait<i32> as Assoc>::Ty`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/associated-item/associated-item-duplicate-bounds.stderr b/tests/ui/associated-item/associated-item-duplicate-bounds.stderr
index f2e4ca524a4..0c8dc9d7fd6 100644
--- a/tests/ui/associated-item/associated-item-duplicate-bounds.stderr
+++ b/tests/ui/associated-item/associated-item-duplicate-bounds.stderr
@@ -7,5 +7,5 @@ LL |     links: [u32; A::LINKS], // Shouldn't suggest bounds already there.
    = note: type parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-item/associated-item-duplicate-names-2.stderr b/tests/ui/associated-item/associated-item-duplicate-names-2.stderr
index 0b96a6bd7c0..ee0686b0f91 100644
--- a/tests/ui/associated-item/associated-item-duplicate-names-2.stderr
+++ b/tests/ui/associated-item/associated-item-duplicate-names-2.stderr
@@ -6,6 +6,6 @@ LL |     const bar: bool = true;
 LL |     fn bar() {}
    |     ^^^^^^^^ duplicate definitions for `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/associated-item/impl-duplicate-methods.stderr b/tests/ui/associated-item/impl-duplicate-methods.stderr
index 6f753845ac8..fbd2434003a 100644
--- a/tests/ui/associated-item/impl-duplicate-methods.stderr
+++ b/tests/ui/associated-item/impl-duplicate-methods.stderr
@@ -6,6 +6,6 @@ LL |     fn orange(&self) {}
 LL |     fn orange(&self) {}
    |     ^^^^^^^^^^^^^^^^ duplicate definitions for `orange`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/associated-type-bounds/ambiguous-associated-type2.stderr b/tests/ui/associated-type-bounds/ambiguous-associated-type2.stderr
index f2604f0ba88..9b077a4d3ef 100644
--- a/tests/ui/associated-type-bounds/ambiguous-associated-type2.stderr
+++ b/tests/ui/associated-type-bounds/ambiguous-associated-type2.stderr
@@ -12,6 +12,6 @@ LL | trait Baz: Foo + Bar<Self::Item> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-type-bounds/assoc-type-eq-with-dyn-atb-fail.stderr b/tests/ui/associated-type-bounds/assoc-type-eq-with-dyn-atb-fail.stderr
index a32ab453152..7942992874d 100644
--- a/tests/ui/associated-type-bounds/assoc-type-eq-with-dyn-atb-fail.stderr
+++ b/tests/ui/associated-type-bounds/assoc-type-eq-with-dyn-atb-fail.stderr
@@ -4,6 +4,6 @@ error[E0277]: the trait bound `String: Copy` is not satisfied
 LL |     fn func() -> Self::Out {
    |                  ^^^^^^^^^ the trait `Copy` is not implemented for `String`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-type-bounds/bad-universal-in-dyn-in-where-clause.stderr b/tests/ui/associated-type-bounds/bad-universal-in-dyn-in-where-clause.stderr
index 6fa266d23d4..fe300a7de42 100644
--- a/tests/ui/associated-type-bounds/bad-universal-in-dyn-in-where-clause.stderr
+++ b/tests/ui/associated-type-bounds/bad-universal-in-dyn-in-where-clause.stderr
@@ -4,5 +4,5 @@ error: associated type bounds are only allowed in where clauses and function sig
 LL |     dyn for<'j> B<AssocType: 'j>:,
    |                   ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-type-bounds/bad-universal-in-impl-sig.stderr b/tests/ui/associated-type-bounds/bad-universal-in-impl-sig.stderr
index 8b66627d57f..7bdb2c5a7c2 100644
--- a/tests/ui/associated-type-bounds/bad-universal-in-impl-sig.stderr
+++ b/tests/ui/associated-type-bounds/bad-universal-in-impl-sig.stderr
@@ -4,5 +4,5 @@ error: associated type bounds are only allowed in where clauses and function sig
 LL | impl dyn Trait<Item: Trait2> {}
    |                ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-type-bounds/binder-on-bound.stderr b/tests/ui/associated-type-bounds/binder-on-bound.stderr
index f71f72bfb94..d09ad73a61f 100644
--- a/tests/ui/associated-type-bounds/binder-on-bound.stderr
+++ b/tests/ui/associated-type-bounds/binder-on-bound.stderr
@@ -4,5 +4,5 @@ error: `for<...>` is not allowed on associated type bounds
 LL | fn foo() where Trait<for<'a> Bound<'a> = &'a ()> {
    |                      ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-type-bounds/const-projection-err.gce.stderr b/tests/ui/associated-type-bounds/const-projection-err.gce.stderr
index 0f1ec9ad052..0b620707497 100644
--- a/tests/ui/associated-type-bounds/const-projection-err.gce.stderr
+++ b/tests/ui/associated-type-bounds/const-projection-err.gce.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `foo`
 LL | fn foo<T: TraitWAssocConst<A = 1>>() {}
    |                            ^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-type-bounds/const-projection-err.stock.stderr b/tests/ui/associated-type-bounds/const-projection-err.stock.stderr
index bf0824259a5..e782571c7de 100644
--- a/tests/ui/associated-type-bounds/const-projection-err.stock.stderr
+++ b/tests/ui/associated-type-bounds/const-projection-err.stock.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `foo`
 LL | fn foo<T: TraitWAssocConst<A = 1>>() {}
    |                            ^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-type-bounds/consts.stderr b/tests/ui/associated-type-bounds/consts.stderr
index ddfb6612b08..eef24c8827b 100644
--- a/tests/ui/associated-type-bounds/consts.stderr
+++ b/tests/ui/associated-type-bounds/consts.stderr
@@ -6,5 +6,5 @@ LL | pub fn accept(_: impl Trait<K: Copy>) {}
    |
    = note: trait bounds not allowed on associated constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-type-bounds/do-not-look-at-parent-item-in-suggestion-for-type-param-of-current-assoc-item.stderr b/tests/ui/associated-type-bounds/do-not-look-at-parent-item-in-suggestion-for-type-param-of-current-assoc-item.stderr
index 78bf93c32d5..1f99d7db0b0 100644
--- a/tests/ui/associated-type-bounds/do-not-look-at-parent-item-in-suggestion-for-type-param-of-current-assoc-item.stderr
+++ b/tests/ui/associated-type-bounds/do-not-look-at-parent-item-in-suggestion-for-type-param-of-current-assoc-item.stderr
@@ -13,6 +13,6 @@ LL |         let _low = self.lows.remove(low.identify()).unwrap();
 note: method defined here
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-type-bounds/issue-102335-ty.stderr b/tests/ui/associated-type-bounds/issue-102335-ty.stderr
index 8777b296515..561ca15ab0d 100644
--- a/tests/ui/associated-type-bounds/issue-102335-ty.stderr
+++ b/tests/ui/associated-type-bounds/issue-102335-ty.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     type A: S<C<i32 = u32> = ()>;
    |                 ^^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/associated-type-bounds/issue-104916.stderr b/tests/ui/associated-type-bounds/issue-104916.stderr
index 35435962ffe..65c89735c5d 100644
--- a/tests/ui/associated-type-bounds/issue-104916.stderr
+++ b/tests/ui/associated-type-bounds/issue-104916.stderr
@@ -4,5 +4,5 @@ error: associated type bounds are only allowed in where clauses and function sig
 LL |     dyn for<'j> B<AssocType: 'j>:,
    |                   ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-type-bounds/issue-71443-1.stderr b/tests/ui/associated-type-bounds/issue-71443-1.stderr
index 09c8ec2e289..6abaaf8e182 100644
--- a/tests/ui/associated-type-bounds/issue-71443-1.stderr
+++ b/tests/ui/associated-type-bounds/issue-71443-1.stderr
@@ -6,6 +6,6 @@ LL | fn hello<F: for<'a> Iterator<Item: 'a>>() {
 LL |     Incorrect
    |     ^^^^^^^^^ expected `()`, found `Incorrect`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-type-bounds/return-type-notation/basic.without.stderr b/tests/ui/associated-type-bounds/return-type-notation/basic.without.stderr
index 5b96676d037..f576cc9c95f 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/basic.without.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/basic.without.stderr
@@ -25,5 +25,5 @@ note: required by a bound in `is_send`
 LL | fn is_send(_: impl Send) {}
    |                    ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/equality.stderr b/tests/ui/associated-type-bounds/return-type-notation/equality.stderr
index 1a2f8471524..d432e957735 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/equality.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/equality.stderr
@@ -13,5 +13,5 @@ error: return type notation is not allowed to use type equality
 LL | fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/missing.stderr b/tests/ui/associated-type-bounds/return-type-notation/missing.stderr
index fb6538fa05c..3ca5e66866d 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/missing.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/missing.stderr
@@ -13,5 +13,5 @@ error: cannot find associated function `methid` for `Trait`
 LL | fn bar<T: Trait<methid(): Send>>() {}
    |                 ^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/non-rpitit.stderr b/tests/ui/associated-type-bounds/return-type-notation/non-rpitit.stderr
index 31b793995f8..3e307c5f42c 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/non-rpitit.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/non-rpitit.stderr
@@ -18,5 +18,5 @@ LL | fn test<T: Trait<method(): Send>>() {}
    |
    = note: function returns `()`, which is not compatible with associated type return bounds
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/unpretty-parenthesized.stderr b/tests/ui/associated-type-bounds/return-type-notation/unpretty-parenthesized.stderr
index 77e015b4160..f27603e3719 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/unpretty-parenthesized.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/unpretty-parenthesized.stderr
@@ -7,6 +7,6 @@ LL | fn foo<T: Trait<method(i32): Send>>() {}
    = note: see issue #52662 <https://github.com/rust-lang/rust/issues/52662> for more information
    = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr b/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr
index b104f38ce90..7ca9aff4322 100644
--- a/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr
+++ b/tests/ui/associated-type-bounds/suggest-contraining-assoc-type-because-of-assoc-const.stderr
@@ -11,6 +11,6 @@ help: consider constraining the associated type `<C as O>::M` to `u8`
 LL | impl<C: O<M = u8>> U<C> for u16 {
    |          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-types/associated-type-macro.stderr b/tests/ui/associated-types/associated-type-macro.stderr
index 6a4cf99c474..dc540a475c3 100644
--- a/tests/ui/associated-types/associated-type-macro.stderr
+++ b/tests/ui/associated-types/associated-type-macro.stderr
@@ -4,5 +4,5 @@ error: macros cannot use qualified paths
 LL |     <() as module>::mac!();
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr b/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr
index fbc4ccd4cf4..ebe56c8cd68 100644
--- a/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr
+++ b/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Add<RHS=Self> {
    | ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-bound-failure.stderr b/tests/ui/associated-types/associated-types-bound-failure.stderr
index 3eda22796e0..0b404819c2c 100644
--- a/tests/ui/associated-types/associated-types-bound-failure.stderr
+++ b/tests/ui/associated-types/associated-types-bound-failure.stderr
@@ -11,6 +11,6 @@ help: consider further restricting the associated type
 LL |     where G : GetToInt, <G as GetToInt>::R: ToInt
    |                       +++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-eq-1.stderr b/tests/ui/associated-types/associated-types-eq-1.stderr
index e9ace7d2574..14ef3687674 100644
--- a/tests/ui/associated-types/associated-types-eq-1.stderr
+++ b/tests/ui/associated-types/associated-types-eq-1.stderr
@@ -15,6 +15,6 @@ help: you might be missing a type parameter
 LL | fn foo2<I: Foo, A>(x: I) {
    |               +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/associated-types/associated-types-eq-2.stderr b/tests/ui/associated-types/associated-types-eq-2.stderr
index 23ee8cd23b5..447b8413ee2 100644
--- a/tests/ui/associated-types/associated-types-eq-2.stderr
+++ b/tests/ui/associated-types/associated-types-eq-2.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL | fn baz<I: Foo>(x: &<I as Foo<A=Bar>>::A) {}
    |                              ^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/associated-types/associated-types-eq-expr-path.stderr b/tests/ui/associated-types/associated-types-eq-expr-path.stderr
index bd354cf3e16..7559f3b7c2e 100644
--- a/tests/ui/associated-types/associated-types-eq-expr-path.stderr
+++ b/tests/ui/associated-types/associated-types-eq-expr-path.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     let x: isize = Foo::<A=usize>::bar();
    |                          ^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/associated-types/associated-types-for-unimpl-trait.stderr b/tests/ui/associated-types/associated-types-for-unimpl-trait.stderr
index 6552c8be780..17941b6bf1e 100644
--- a/tests/ui/associated-types/associated-types-for-unimpl-trait.stderr
+++ b/tests/ui/associated-types/associated-types-for-unimpl-trait.stderr
@@ -9,6 +9,6 @@ help: consider further restricting `Self`
 LL |     fn uhoh<U:Get>(&self, foo: U, bar: <Self as Get>::Value) where Self: Get {}
    |                                                              +++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-invalid-trait-ref-issue-18865.stderr b/tests/ui/associated-types/associated-types-invalid-trait-ref-issue-18865.stderr
index 676d6353d98..adde31b4a32 100644
--- a/tests/ui/associated-types/associated-types-invalid-trait-ref-issue-18865.stderr
+++ b/tests/ui/associated-types/associated-types-invalid-trait-ref-issue-18865.stderr
@@ -9,6 +9,6 @@ help: consider further restricting this bound
 LL | fn f<T:Foo<isize> + Foo<usize>>(t: &T) {
    |                   ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-issue-17359.stderr b/tests/ui/associated-types/associated-types-issue-17359.stderr
index 9e40d809586..f5397b8ecdc 100644
--- a/tests/ui/associated-types/associated-types-issue-17359.stderr
+++ b/tests/ui/associated-types/associated-types-issue-17359.stderr
@@ -7,6 +7,6 @@ LL |     type Type;
 LL | impl Trait for isize {}
    | ^^^^^^^^^^^^^^^^^^^^ missing `Type` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/associated-types/associated-types-issue-20346.stderr b/tests/ui/associated-types/associated-types-issue-20346.stderr
index f384079862f..8e6b847b3aa 100644
--- a/tests/ui/associated-types/associated-types-issue-20346.stderr
+++ b/tests/ui/associated-types/associated-types-issue-20346.stderr
@@ -22,6 +22,6 @@ note: required by a bound in `is_iterator_of`
 LL | fn is_iterator_of<A, I: Iterator<Item=A>>(_: &I) {}
    |                                  ^^^^^^ required by this bound in `is_iterator_of`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/associated-types-no-suitable-bound.stderr b/tests/ui/associated-types/associated-types-no-suitable-bound.stderr
index b2ee1b5e6d0..fe1be6be015 100644
--- a/tests/ui/associated-types/associated-types-no-suitable-bound.stderr
+++ b/tests/ui/associated-types/associated-types-no-suitable-bound.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL |     fn uhoh<T: Get>(foo: <T as Get>::Value) {}
    |              +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-no-suitable-supertrait-2.stderr b/tests/ui/associated-types/associated-types-no-suitable-supertrait-2.stderr
index 2e40dbd065d..b586053a5bc 100644
--- a/tests/ui/associated-types/associated-types-no-suitable-supertrait-2.stderr
+++ b/tests/ui/associated-types/associated-types-no-suitable-supertrait-2.stderr
@@ -9,6 +9,6 @@ help: consider further restricting `Self`
 LL |     fn uhoh<U:Get>(&self, foo: U, bar: <Self as Get>::Value) where Self: Get {}
    |                                                              +++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-outlives.stderr b/tests/ui/associated-types/associated-types-outlives.stderr
index 2fe3f2d4a02..deeedd22266 100644
--- a/tests/ui/associated-types/associated-types-outlives.stderr
+++ b/tests/ui/associated-types/associated-types-outlives.stderr
@@ -11,6 +11,6 @@ LL |         drop(x);
 LL |         return f(y);
    |                  - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/associated-types/associated-types-overridden-binding-2.stderr b/tests/ui/associated-types/associated-types-overridden-binding-2.stderr
index fdec01b95e3..4dfd275a190 100644
--- a/tests/ui/associated-types/associated-types-overridden-binding-2.stderr
+++ b/tests/ui/associated-types/associated-types-overridden-binding-2.stderr
@@ -6,6 +6,6 @@ LL |     let _: &dyn I32Iterator<Item = u32> = &vec![42].into_iter();
    |
    = note: required for the cast from `&std::vec::IntoIter<u32>` to `&dyn Iterator<Item = u32, Item = i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/associated-types-project-from-hrtb-in-fn.stderr b/tests/ui/associated-types/associated-types-project-from-hrtb-in-fn.stderr
index c508006c3a4..83bad291e56 100644
--- a/tests/ui/associated-types/associated-types-project-from-hrtb-in-fn.stderr
+++ b/tests/ui/associated-types/associated-types-project-from-hrtb-in-fn.stderr
@@ -9,6 +9,6 @@ help: use a fully qualified path with inferred lifetimes
 LL |     x: <I as Foo<&isize>>::A)
    |        ~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0212`.
diff --git a/tests/ui/associated-types/associated-types-projection-to-unrelated-trait-in-method-without-default.stderr b/tests/ui/associated-types/associated-types-projection-to-unrelated-trait-in-method-without-default.stderr
index 2e67c21940f..64a88525af8 100644
--- a/tests/ui/associated-types/associated-types-projection-to-unrelated-trait-in-method-without-default.stderr
+++ b/tests/ui/associated-types/associated-types-projection-to-unrelated-trait-in-method-without-default.stderr
@@ -9,6 +9,6 @@ help: consider further restricting `Self`
 LL |     fn okay<U:Get>(&self, foo: U, bar: <Self as Get>::Value) where Self: Get;
    |                                                              +++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/associated-types-unconstrained.stderr b/tests/ui/associated-types/associated-types-unconstrained.stderr
index ef9b7cae01b..4221a064ff9 100644
--- a/tests/ui/associated-types/associated-types-unconstrained.stderr
+++ b/tests/ui/associated-types/associated-types-unconstrained.stderr
@@ -12,6 +12,6 @@ help: use the fully-qualified path to the only available implementation
 LL |     let x: isize = <isize as Foo>::bar();
    |                    +++++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/associated-types/associated-types-unsized.stderr b/tests/ui/associated-types/associated-types-unsized.stderr
index bec9b1500c9..e46b2a39464 100644
--- a/tests/ui/associated-types/associated-types-unsized.stderr
+++ b/tests/ui/associated-types/associated-types-unsized.stderr
@@ -12,6 +12,6 @@ help: consider further restricting the associated type
 LL | fn foo<T:Get>(t: T) where <T as Get>::Value: Sized {
    |                     ++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr b/tests/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr
index 4de4afb6e92..8ccfb212216 100644
--- a/tests/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr
+++ b/tests/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr
@@ -10,6 +10,6 @@ help: consider using the `'static` lifetime
 LL | fn elision<T: Fn() -> &'static i32>() {
    |                        +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/associated-types/bound-lifetime-in-binding-only.ok.stderr b/tests/ui/associated-types/bound-lifetime-in-binding-only.ok.stderr
index b709fae5a8e..435e224bd89 100644
--- a/tests/ui/associated-types/bound-lifetime-in-binding-only.ok.stderr
+++ b/tests/ui/associated-types/bound-lifetime-in-binding-only.ok.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() { }
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/bound-lifetime-in-return-only.elision.stderr b/tests/ui/associated-types/bound-lifetime-in-return-only.elision.stderr
index 7753d186504..0593a62a750 100644
--- a/tests/ui/associated-types/bound-lifetime-in-return-only.elision.stderr
+++ b/tests/ui/associated-types/bound-lifetime-in-return-only.elision.stderr
@@ -10,6 +10,6 @@ help: consider using the `'static` lifetime
 LL | fn elision(_: fn() -> &'static i32) {
    |                        +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/associated-types/bound-lifetime-in-return-only.local.stderr b/tests/ui/associated-types/bound-lifetime-in-return-only.local.stderr
index 788cf667c8d..138b777e664 100644
--- a/tests/ui/associated-types/bound-lifetime-in-return-only.local.stderr
+++ b/tests/ui/associated-types/bound-lifetime-in-return-only.local.stderr
@@ -4,6 +4,6 @@ error[E0581]: return type references lifetime `'a`, which is not constrained by
 LL |     let _: for<'a> fn() -> &'a i32 = loop { };
    |                            ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0581`.
diff --git a/tests/ui/associated-types/bound-lifetime-in-return-only.ok.stderr b/tests/ui/associated-types/bound-lifetime-in-return-only.ok.stderr
index 1c0d3ac1058..1815a7be7ee 100644
--- a/tests/ui/associated-types/bound-lifetime-in-return-only.ok.stderr
+++ b/tests/ui/associated-types/bound-lifetime-in-return-only.ok.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() { }
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/bound-lifetime-in-return-only.structure.stderr b/tests/ui/associated-types/bound-lifetime-in-return-only.structure.stderr
index f7833500d00..c7d097d3746 100644
--- a/tests/ui/associated-types/bound-lifetime-in-return-only.structure.stderr
+++ b/tests/ui/associated-types/bound-lifetime-in-return-only.structure.stderr
@@ -4,6 +4,6 @@ error[E0581]: return type references lifetime `'a`, which is not constrained by
 LL |     x: for<'a> fn() -> &'a i32
    |                        ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0581`.
diff --git a/tests/ui/associated-types/cache/project-fn-ret-contravariant.transmute.stderr b/tests/ui/associated-types/cache/project-fn-ret-contravariant.transmute.stderr
index 6d8ab2c3fdc..6ae13e9222a 100644
--- a/tests/ui/associated-types/cache/project-fn-ret-contravariant.transmute.stderr
+++ b/tests/ui/associated-types/cache/project-fn-ret-contravariant.transmute.stderr
@@ -6,5 +6,5 @@ LL | fn baz<'a,'b>(x: &'a u32) -> &'static u32 {
 LL |    bar(foo, x)
    |    ^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/cache/project-fn-ret-invariant.transmute.stderr b/tests/ui/associated-types/cache/project-fn-ret-invariant.transmute.stderr
index b64cb2c3d0b..b8100f6dfae 100644
--- a/tests/ui/associated-types/cache/project-fn-ret-invariant.transmute.stderr
+++ b/tests/ui/associated-types/cache/project-fn-ret-invariant.transmute.stderr
@@ -11,5 +11,5 @@ LL |     bar(foo, x)
    = note: the struct `Type<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/defaults-wf.stderr b/tests/ui/associated-types/defaults-wf.stderr
index fc830b8d676..aeb4e47abcb 100644
--- a/tests/ui/associated-types/defaults-wf.stderr
+++ b/tests/ui/associated-types/defaults-wf.stderr
@@ -8,6 +8,6 @@ LL |     type Ty = Vec<[u8]>;
 note: required by a bound in `Vec`
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/dont-suggest-cyclic-constraint.stderr b/tests/ui/associated-types/dont-suggest-cyclic-constraint.stderr
index 3ecac9c83e5..606084aea34 100644
--- a/tests/ui/associated-types/dont-suggest-cyclic-constraint.stderr
+++ b/tests/ui/associated-types/dont-suggest-cyclic-constraint.stderr
@@ -7,6 +7,6 @@ LL |     debug_assert_eq!(iter.next(), Some(value));
    = note: expected enum `Option<<I as Iterator>::Item>`
               found enum `Option<&<I as Iterator>::Item>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-types/higher-ranked-projection.bad.stderr b/tests/ui/associated-types/higher-ranked-projection.bad.stderr
index 239f4553938..09606a1944d 100644
--- a/tests/ui/associated-types/higher-ranked-projection.bad.stderr
+++ b/tests/ui/associated-types/higher-ranked-projection.bad.stderr
@@ -12,6 +12,6 @@ note: the lifetime requirement is introduced here
 LL |     where for<'a> &'a T: Mirror<Image=U>
    |                                 ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-1.stderr b/tests/ui/associated-types/hr-associated-type-bound-1.stderr
index b380a1b6f06..ab5dc803cdf 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-1.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-1.stderr
@@ -14,6 +14,6 @@ LL | where
 LL |     for<'b> <Self as X<'b>>::U: Clone,
    |                                 ^^^^^ required by this bound in `X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-2.stderr b/tests/ui/associated-types/hr-associated-type-bound-2.stderr
index 8ccbc9fb514..2a7d75ef29b 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-2.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-2.stderr
@@ -18,6 +18,6 @@ LL |     for<'b> <Self as X<'b>>::U: Clone,
    = note: 128 redundant requirements hidden
    = note: required for `u32` to implement `for<'b> X<'b>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-object.stderr b/tests/ui/associated-types/hr-associated-type-bound-object.stderr
index a0a6f76a583..8c91211b964 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-object.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-object.stderr
@@ -13,6 +13,6 @@ LL | where
 LL |     for<'b> <Self as X<'b>>::U: Clone,
    |                                 ^^^^^ required by this bound in `X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-param-1.stderr b/tests/ui/associated-types/hr-associated-type-bound-param-1.stderr
index e249f2e0c27..9e039364224 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-param-1.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-param-1.stderr
@@ -14,6 +14,6 @@ LL | trait Y<'a, T: ?Sized>
 LL |     for<'b> <Self as Y<'b, T>>::V: Clone,
    |                                    ^^^^^ required by this bound in `Y`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-param-3.stderr b/tests/ui/associated-types/hr-associated-type-bound-param-3.stderr
index f49439d3573..f8be4ec2410 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-param-3.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-param-3.stderr
@@ -14,6 +14,6 @@ LL | trait X<'a, T>
 LL |     for<'b> <T as X<'b, T>>::U: Clone,
    |                                 ^^^^^ required by this bound in `X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-param-4.stderr b/tests/ui/associated-types/hr-associated-type-bound-param-4.stderr
index f8733b423d7..22c4bd68690 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-param-4.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-param-4.stderr
@@ -14,6 +14,6 @@ LL | trait X<'a, T>
 LL |     for<'b> <(T,) as X<'b, T>>::U: Clone,
    |                                    ^^^^^ required by this bound in `X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr b/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
index bd6e627a3d0..da988f4cfc1 100644
--- a/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
+++ b/tests/ui/associated-types/hr-associated-type-bound-param-6.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | impl<S, T: for<'b> X<'b, T>> X<'_, T> for (S,) {
    |          ++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/hr-associated-type-projection-1.stderr b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
index 425cfdca01d..59b52521ef8 100644
--- a/tests/ui/associated-types/hr-associated-type-projection-1.stderr
+++ b/tests/ui/associated-types/hr-associated-type-projection-1.stderr
@@ -21,6 +21,6 @@ help: consider further restricting this bound
 LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<'_, T> for T {
    |                               ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/impl-trait-return-missing-constraint.stderr b/tests/ui/associated-types/impl-trait-return-missing-constraint.stderr
index fbd76a64c1e..24409b32ad3 100644
--- a/tests/ui/associated-types/impl-trait-return-missing-constraint.stderr
+++ b/tests/ui/associated-types/impl-trait-return-missing-constraint.stderr
@@ -19,6 +19,6 @@ help: consider constraining the associated type `<impl Bar as Foo>::Item` to `i3
 LL | fn bar() -> impl Bar<Item = i32> {
    |                     ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/impl-wf-cycle-1.stderr b/tests/ui/associated-types/impl-wf-cycle-1.stderr
index 53022dcb4c7..5fa36733f66 100644
--- a/tests/ui/associated-types/impl-wf-cycle-1.stderr
+++ b/tests/ui/associated-types/impl-wf-cycle-1.stderr
@@ -19,6 +19,6 @@ LL |     Self::A: Baz,
    = note: 1 redundant requirement hidden
    = note: required for `(T,)` to implement `Grault`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/associated-types/impl-wf-cycle-2.stderr b/tests/ui/associated-types/impl-wf-cycle-2.stderr
index 81c58be927e..17a96bbd934 100644
--- a/tests/ui/associated-types/impl-wf-cycle-2.stderr
+++ b/tests/ui/associated-types/impl-wf-cycle-2.stderr
@@ -16,6 +16,6 @@ LL | impl<T: Grault> Grault for (T,)
 LL |     Self::A: Copy,
    |              ---- unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/associated-types/issue-19883.stderr b/tests/ui/associated-types/issue-19883.stderr
index bd6a86b7420..35184e852cf 100644
--- a/tests/ui/associated-types/issue-19883.stderr
+++ b/tests/ui/associated-types/issue-19883.stderr
@@ -10,6 +10,6 @@ LL |         <Dst as From<Self>>::Dst
    |                              not found in `From`
    |                              help: maybe you meant this associated type: `Output`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0576`.
diff --git a/tests/ui/associated-types/issue-20005.stderr b/tests/ui/associated-types/issue-20005.stderr
index c8e57df0d9f..02470a44249 100644
--- a/tests/ui/associated-types/issue-20005.stderr
+++ b/tests/ui/associated-types/issue-20005.stderr
@@ -18,6 +18,6 @@ help: consider relaxing the implicit `Sized` restriction
 LL | trait From<Src: ?Sized> {
    |               ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-20825.stderr b/tests/ui/associated-types/issue-20825.stderr
index 02b3536e2d1..e4f1fc62387 100644
--- a/tests/ui/associated-types/issue-20825.stderr
+++ b/tests/ui/associated-types/issue-20825.stderr
@@ -12,6 +12,6 @@ LL | pub trait Processor: Subscriber<Input = Self::Input> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/associated-types/issue-22037.stderr b/tests/ui/associated-types/issue-22037.stderr
index 0e019f10f37..b02dad97d35 100644
--- a/tests/ui/associated-types/issue-22037.stderr
+++ b/tests/ui/associated-types/issue-22037.stderr
@@ -9,6 +9,6 @@ LL |     fn a(&self) -> <Self as A>::X;
    |                                 not found in `A`
    |                                 help: maybe you meant this associated type: `Output`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0576`.
diff --git a/tests/ui/associated-types/issue-23595-1.stderr b/tests/ui/associated-types/issue-23595-1.stderr
index 3443c4925f4..f9d58c23cbb 100644
--- a/tests/ui/associated-types/issue-23595-1.stderr
+++ b/tests/ui/associated-types/issue-23595-1.stderr
@@ -8,6 +8,6 @@ LL |     type ChildKey;
 LL |     type Children = dyn Index<Self::ChildKey, Output=dyn Hierarchy>;
    |     ------------- `Children` defined here                ^^^^^^^^^ help: specify the associated types: `Hierarchy<Value = Type, ChildKey = Type, Children = Type>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0191`.
diff --git a/tests/ui/associated-types/issue-23595-2.stderr b/tests/ui/associated-types/issue-23595-2.stderr
index 73effa9f955..2671bf57d0c 100644
--- a/tests/ui/associated-types/issue-23595-2.stderr
+++ b/tests/ui/associated-types/issue-23595-2.stderr
@@ -4,6 +4,6 @@ error[E0220]: associated type `anything_here_kills_it` not found for `Self`
 LL |     type B = C<Self::anything_here_kills_it>;
    |                      ^^^^^^^^^^^^^^^^^^^^^^ help: `Self` has the following associated type: `B`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/ui/associated-types/issue-25700.stderr b/tests/ui/associated-types/issue-25700.stderr
index fa309a55c3c..4e432c0e702 100644
--- a/tests/ui/associated-types/issue-25700.stderr
+++ b/tests/ui/associated-types/issue-25700.stderr
@@ -8,6 +8,6 @@ LL |     drop(t);
 LL |     drop(t);
    |          ^ value used here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/associated-types/issue-26681.stderr b/tests/ui/associated-types/issue-26681.stderr
index 977620d9052..b64bcee07f0 100644
--- a/tests/ui/associated-types/issue-26681.stderr
+++ b/tests/ui/associated-types/issue-26681.stderr
@@ -9,6 +9,6 @@ LL |     const C: <Self::Fv as Foo>::Bar = 6665;
    = note: expected associated type `<<Self as Baz>::Fv as Foo>::Bar`
                          found type `{integer}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr b/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
index a14a273b3ec..70bf90150b8 100644
--- a/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
+++ b/tests/ui/associated-types/issue-27675-unchecked-bounds.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
    |                  +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-32323.stderr b/tests/ui/associated-types/issue-32323.stderr
index 8212c607e11..6b0ef1efdd0 100644
--- a/tests/ui/associated-types/issue-32323.stderr
+++ b/tests/ui/associated-types/issue-32323.stderr
@@ -13,6 +13,6 @@ help: consider constraining the associated type `<T as Tr<'a>>::Out` to `()`
 LL | pub fn f<'a, T: Tr<'a, Out = ()>>() -> <T as Tr<'a>>::Out {}
    |                      ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/associated-types/issue-36499.rs b/tests/ui/associated-types/issue-36499.rs
index 7f8f13ef8d4..3d6f11faff7 100644
--- a/tests/ui/associated-types/issue-36499.rs
+++ b/tests/ui/associated-types/issue-36499.rs
@@ -1,4 +1,4 @@
-// error-pattern: aborting due to previous error
+// error-pattern: aborting due to 1 previous error
 
 fn main() {
     2 + +2;
diff --git a/tests/ui/associated-types/issue-36499.stderr b/tests/ui/associated-types/issue-36499.stderr
index 80e42b61d20..dd91bac8158 100644
--- a/tests/ui/associated-types/issue-36499.stderr
+++ b/tests/ui/associated-types/issue-36499.stderr
@@ -10,5 +10,5 @@ LL -     2 + +2;
 LL +     2 + 2;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/issue-38821.stderr b/tests/ui/associated-types/issue-38821.stderr
index a52a9c138f1..8b628f5ae6d 100644
--- a/tests/ui/associated-types/issue-38821.stderr
+++ b/tests/ui/associated-types/issue-38821.stderr
@@ -17,6 +17,6 @@ help: consider further restricting the associated type
 LL |     Expr: Expression<SqlType=<Col::SqlType as IntoNullable>::Nullable>, <Col as Expression>::SqlType: NotNull,
    |                                                                       +++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-43784-associated-type.stderr b/tests/ui/associated-types/issue-43784-associated-type.stderr
index 50fa7d1ac4d..529fc1f119a 100644
--- a/tests/ui/associated-types/issue-43784-associated-type.stderr
+++ b/tests/ui/associated-types/issue-43784-associated-type.stderr
@@ -19,6 +19,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::marker::Copy> Complete for T {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-44153.stderr b/tests/ui/associated-types/issue-44153.stderr
index 73365d64d56..384b8685a1e 100644
--- a/tests/ui/associated-types/issue-44153.stderr
+++ b/tests/ui/associated-types/issue-44153.stderr
@@ -17,6 +17,6 @@ LL | impl<'a> Visit for () where
 LL |     (): Array<Element=&'a ()>,
    |               -------------- unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/issue-47814.stderr b/tests/ui/associated-types/issue-47814.stderr
index 2e4ddb81166..7382426b0ff 100644
--- a/tests/ui/associated-types/issue-47814.stderr
+++ b/tests/ui/associated-types/issue-47814.stderr
@@ -10,5 +10,5 @@ note: not a concrete type
 LL | impl<'a> ArpIPv4<'a> {
    |          ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/issue-54108.stderr b/tests/ui/associated-types/issue-54108.stderr
index 6ff5e454234..f300208fcc8 100644
--- a/tests/ui/associated-types/issue-54108.stderr
+++ b/tests/ui/associated-types/issue-54108.stderr
@@ -15,6 +15,6 @@ help: consider further restricting the associated type
 LL |     T: SubEncoder, <T as SubEncoder>::ActualSize: Add
    |                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-62200.stderr b/tests/ui/associated-types/issue-62200.stderr
index 04f0728f58e..7b040f8aa14 100644
--- a/tests/ui/associated-types/issue-62200.stderr
+++ b/tests/ui/associated-types/issue-62200.stderr
@@ -7,6 +7,6 @@ LL | fn foo(x: impl Fn(<S as T<'_>>::A) -> <S as T<'_>>::A) {}
    = note: lifetimes appearing in an associated or opaque type are not considered constrained
    = note: consider introducing a named lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0582`.
diff --git a/tests/ui/associated-types/issue-63593.stderr b/tests/ui/associated-types/issue-63593.stderr
index f643ec3ff1f..67151431a67 100644
--- a/tests/ui/associated-types/issue-63593.stderr
+++ b/tests/ui/associated-types/issue-63593.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL | trait MyTrait: Sized {
    |              +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-64855.stderr b/tests/ui/associated-types/issue-64855.stderr
index f1016f0e3a1..7c09abdb3b6 100644
--- a/tests/ui/associated-types/issue-64855.stderr
+++ b/tests/ui/associated-types/issue-64855.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | pub trait Foo {
    | ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/issue-72806.stderr b/tests/ui/associated-types/issue-72806.stderr
index e95943f34d5..9cb615bbb28 100644
--- a/tests/ui/associated-types/issue-72806.stderr
+++ b/tests/ui/associated-types/issue-72806.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Bar::Sibling`
 LL |     type Sibling: Bar2<Ok=char>;
    |                        ^^^^^^^ required by this bound in `Bar::Sibling`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/issue-85103-layout-debug.stderr b/tests/ui/associated-types/issue-85103-layout-debug.stderr
index 0bdea10ba47..c79543e73cd 100644
--- a/tests/ui/associated-types/issue-85103-layout-debug.stderr
+++ b/tests/ui/associated-types/issue-85103-layout-debug.stderr
@@ -11,6 +11,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | type Edges<'a, E> where [E]: ToOwned = Cow<'a, [E]>;
    |                   ++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/associated-types/point-at-type-on-obligation-failure.stderr b/tests/ui/associated-types/point-at-type-on-obligation-failure.stderr
index 9afbe82c321..1c9de509e68 100644
--- a/tests/ui/associated-types/point-at-type-on-obligation-failure.stderr
+++ b/tests/ui/associated-types/point-at-type-on-obligation-failure.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Bar::Sibling`
 LL |     type Sibling: Bar2<Ok=Self::Ok>;
    |                        ^^^^^^^^^^^ required by this bound in `Bar::Sibling`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-types/trait-with-supertraits-needing-sized-self.stderr b/tests/ui/associated-types/trait-with-supertraits-needing-sized-self.stderr
index 8e7cf86c406..99a46dedcdc 100644
--- a/tests/ui/associated-types/trait-with-supertraits-needing-sized-self.stderr
+++ b/tests/ui/associated-types/trait-with-supertraits-needing-sized-self.stderr
@@ -11,6 +11,6 @@ help: consider further restricting `Self`
 LL | trait ArithmeticOps: Add<Output=Self> + Sub<Output=Self> + Mul<Output=Self> + Div<Output=Self> + Sized {}
    |                                                                                                +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr b/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr
index 10691aad04e..1d8d1c67bae 100644
--- a/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr
+++ b/tests/ui/async-await/async-borrowck-escaping-closure-error.stderr
@@ -16,6 +16,6 @@ help: to force the closure to take ownership of `x` (and any other referenced va
 LL |     Box::new((async move || x)())
    |                     ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/async-await/async-fn-path-elision.stderr b/tests/ui/async-await/async-fn-path-elision.stderr
index 224198653dc..4b0139a396c 100644
--- a/tests/ui/async-await/async-fn-path-elision.stderr
+++ b/tests/ui/async-await/async-fn-path-elision.stderr
@@ -9,6 +9,6 @@ help: indicate the anonymous lifetime
 LL | async fn error(lt: HasLifetime<'_>) {
    |                               ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0726`.
diff --git a/tests/ui/async-await/async-is-unwindsafe.stderr b/tests/ui/async-await/async-is-unwindsafe.stderr
index eaa45538050..99bce89e8d3 100644
--- a/tests/ui/async-await/async-is-unwindsafe.stderr
+++ b/tests/ui/async-await/async-is-unwindsafe.stderr
@@ -29,6 +29,6 @@ note: required by a bound in `is_unwindsafe`
 LL | fn is_unwindsafe(_: impl std::panic::UnwindSafe) {}
    |                          ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_unwindsafe`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/await-keyword/post_expansion_error.stderr b/tests/ui/async-await/await-keyword/post_expansion_error.stderr
index 0996c38b3b6..7948fb9564e 100644
--- a/tests/ui/async-await/await-keyword/post_expansion_error.stderr
+++ b/tests/ui/async-await/await-keyword/post_expansion_error.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `)`
 LL |     await!()
    |            ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/awaiting-unsized-param.stderr b/tests/ui/async-await/awaiting-unsized-param.stderr
index 47a5dcebf25..0104736976d 100644
--- a/tests/ui/async-await/awaiting-unsized-param.stderr
+++ b/tests/ui/async-await/awaiting-unsized-param.stderr
@@ -16,6 +16,6 @@ LL | async fn bug<T>(mut f: dyn Future<Output = T> + Unpin) -> T {
    = help: the trait `Sized` is not implemented for `(dyn Future<Output = T> + Unpin + 'static)`
    = note: all values captured by value by a closure must have a statically known size
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/clone-suggestion.stderr b/tests/ui/async-await/clone-suggestion.stderr
index b5c8ef6993d..3374068ed3f 100644
--- a/tests/ui/async-await/clone-suggestion.stderr
+++ b/tests/ui/async-await/clone-suggestion.stderr
@@ -15,6 +15,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |     f.clone().await;
    |      ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/async-await/const-async-fn-in-main.stderr b/tests/ui/async-await/const-async-fn-in-main.stderr
index 10b15170922..06f3e34629a 100644
--- a/tests/ui/async-await/const-async-fn-in-main.stderr
+++ b/tests/ui/async-await/const-async-fn-in-main.stderr
@@ -7,5 +7,5 @@ LL |     const async fn a() {}
    |     |     `async` because of this
    |     `const` because of this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/dont-print-desugared-async.stderr b/tests/ui/async-await/dont-print-desugared-async.stderr
index d80467c7fa8..1dade23f623 100644
--- a/tests/ui/async-await/dont-print-desugared-async.stderr
+++ b/tests/ui/async-await/dont-print-desugared-async.stderr
@@ -4,6 +4,6 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL | async fn async_fn(&ref mut s: &[i32]) {}
    |                    ^^^^^^^^^ cannot borrow as mutable through `&` reference
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/async-await/dont-suggest-await-on-method-return-mismatch.stderr b/tests/ui/async-await/dont-suggest-await-on-method-return-mismatch.stderr
index e65d9d0e5d3..1faaf4ddce2 100644
--- a/tests/ui/async-await/dont-suggest-await-on-method-return-mismatch.stderr
+++ b/tests/ui/async-await/dont-suggest-await-on-method-return-mismatch.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `test` found for opaque type `impl Future<Output =
 LL |     let x: u32 = foo().test();
    |                        ^^^^ method not found in `impl Future<Output = A>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/async-await/dont-suggest-missing-await.stderr b/tests/ui/async-await/dont-suggest-missing-await.stderr
index 1fa4e5db0cb..45a226c31f8 100644
--- a/tests/ui/async-await/dont-suggest-missing-await.stderr
+++ b/tests/ui/async-await/dont-suggest-missing-await.stderr
@@ -21,6 +21,6 @@ help: consider `await`ing on the `Future`
 LL |         take_u32(x.await)
    |                   ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/drop-track-field-assign-nonsend.stderr b/tests/ui/async-await/drop-track-field-assign-nonsend.stderr
index 6c235916d64..9fce4d61b3b 100644
--- a/tests/ui/async-await/drop-track-field-assign-nonsend.stderr
+++ b/tests/ui/async-await/drop-track-field-assign-nonsend.stderr
@@ -19,5 +19,5 @@ note: required by a bound in `assert_send`
 LL | fn assert_send<T: Send>(_: T) {}
    |                   ^^^^ required by this bound in `assert_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/feature-async-closure.stderr b/tests/ui/async-await/feature-async-closure.stderr
index 485a838b67f..c69a0dd9ed9 100644
--- a/tests/ui/async-await/feature-async-closure.stderr
+++ b/tests/ui/async-await/feature-async-closure.stderr
@@ -8,6 +8,6 @@ LL |     let _ = async || {};
    = help: add `#![feature(async_closure)]` to the crate attributes to enable
    = help: to use an async block, remove the `||`: `async {`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/async-await/feature-self-return-type.stderr b/tests/ui/async-await/feature-self-return-type.stderr
index dc160bfbf61..120f1c9b00d 100644
--- a/tests/ui/async-await/feature-self-return-type.stderr
+++ b/tests/ui/async-await/feature-self-return-type.stderr
@@ -11,6 +11,6 @@ LL |
 LL |     };
    |     - `bar` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/async-await/field-assign-nonsend.stderr b/tests/ui/async-await/field-assign-nonsend.stderr
index 3037d702447..418a0829c65 100644
--- a/tests/ui/async-await/field-assign-nonsend.stderr
+++ b/tests/ui/async-await/field-assign-nonsend.stderr
@@ -19,5 +19,5 @@ note: required by a bound in `assert_send`
 LL | fn assert_send<T: Send>(_: T) {}
    |                   ^^^^ required by this bound in `assert_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/future-contains-err-issue-115188.stderr b/tests/ui/async-await/future-contains-err-issue-115188.stderr
index 8fd2550c1c7..0e2da190af7 100644
--- a/tests/ui/async-await/future-contains-err-issue-115188.stderr
+++ b/tests/ui/async-await/future-contains-err-issue-115188.stderr
@@ -4,6 +4,6 @@ error[E0063]: missing field `t` in initializer of `Wrapper<_>`
 LL |     let y = Wrapper { };
    |             ^^^^^^^ missing `t`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0063`.
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-boxed-in-trait.stderr b/tests/ui/async-await/in-trait/async-example-desugared-boxed-in-trait.stderr
index b70b36adb4a..34aded73da5 100644
--- a/tests/ui/async-await/in-trait/async-example-desugared-boxed-in-trait.stderr
+++ b/tests/ui/async-await/in-trait/async-example-desugared-boxed-in-trait.stderr
@@ -12,6 +12,6 @@ LL |     fn foo(&self) -> Pin<Box<dyn Future<Output = i32> + '_>>;
    = note: expected signature `fn(&i32) -> Pin<Box<dyn Future<Output = i32>>>`
               found signature `fn(&i32) -> impl Future<Output = i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr b/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr
index 6392ce86e4a..1462c694e16 100644
--- a/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr
+++ b/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr
@@ -7,5 +7,5 @@ LL |     async fn foo(&self) -> i32;
 LL |     fn foo(&self) -> Pin<Box<dyn Future<Output = i32> + '_>> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr b/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr
index 1eda6fe6532..a2f1060e36f 100644
--- a/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr
+++ b/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr
@@ -7,5 +7,5 @@ LL |     async fn foo(&self) -> i32;
 LL |     fn foo(&self) -> MyFuture {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/in-trait/async-recursive-generic.stderr b/tests/ui/async-await/in-trait/async-recursive-generic.stderr
index cf0bcd741fc..11489c18ad4 100644
--- a/tests/ui/async-await/in-trait/async-recursive-generic.stderr
+++ b/tests/ui/async-await/in-trait/async-recursive-generic.stderr
@@ -7,6 +7,6 @@ LL |     async fn foo_recursive(&self, n: usize) -> T {
    = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`
    = note: consider using the `async_recursion` crate: https://crates.io/crates/async_recursion
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0733`.
diff --git a/tests/ui/async-await/in-trait/async-recursive.stderr b/tests/ui/async-await/in-trait/async-recursive.stderr
index b959652ea16..58796285726 100644
--- a/tests/ui/async-await/in-trait/async-recursive.stderr
+++ b/tests/ui/async-await/in-trait/async-recursive.stderr
@@ -7,6 +7,6 @@ LL |     async fn foo_recursive(&self, n: usize) -> i32 {
    = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`
    = note: consider using the `async_recursion` crate: https://crates.io/crates/async_recursion
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0733`.
diff --git a/tests/ui/async-await/in-trait/fn-not-async-err.stderr b/tests/ui/async-await/in-trait/fn-not-async-err.stderr
index cd085074ae3..f75ccb65d15 100644
--- a/tests/ui/async-await/in-trait/fn-not-async-err.stderr
+++ b/tests/ui/async-await/in-trait/fn-not-async-err.stderr
@@ -7,5 +7,5 @@ LL |     async fn foo(&self) -> i32;
 LL |     fn foo(&self) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/in-trait/generics-mismatch.stderr b/tests/ui/async-await/in-trait/generics-mismatch.stderr
index 647cc698f9f..5f7aeb17117 100644
--- a/tests/ui/async-await/in-trait/generics-mismatch.stderr
+++ b/tests/ui/async-await/in-trait/generics-mismatch.stderr
@@ -11,6 +11,6 @@ LL | impl Foo for () {
 LL |     async fn foo<const N: usize>() {}
    |                  ^^^^^^^^^^^^^^ found const parameter of type `usize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/async-await/in-trait/indirect-recursion-issue-112047.stderr b/tests/ui/async-await/in-trait/indirect-recursion-issue-112047.stderr
index ce02c1e9967..95731b67ccf 100644
--- a/tests/ui/async-await/in-trait/indirect-recursion-issue-112047.stderr
+++ b/tests/ui/async-await/in-trait/indirect-recursion-issue-112047.stderr
@@ -5,6 +5,6 @@ error[E0391]: cycle detected when computing layout of `{async fn body@$DIR/indir
    = note: cycle used when computing layout of `{async block@$DIR/indirect-recursion-issue-112047.rs:6:13: 8:6}`
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/async-await/in-trait/lifetime-mismatch.stderr b/tests/ui/async-await/in-trait/lifetime-mismatch.stderr
index 3841ab9345f..6b8716d2a8d 100644
--- a/tests/ui/async-await/in-trait/lifetime-mismatch.stderr
+++ b/tests/ui/async-await/in-trait/lifetime-mismatch.stderr
@@ -7,6 +7,6 @@ LL |     async fn foo<'a>(&self);
 LL |     async fn foo(&self) {}
    |                 ^ lifetimes do not match method in trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0195`.
diff --git a/tests/ui/async-await/in-trait/missing-send-bound.stderr b/tests/ui/async-await/in-trait/missing-send-bound.stderr
index 139bd06c7df..aeabb5931df 100644
--- a/tests/ui/async-await/in-trait/missing-send-bound.stderr
+++ b/tests/ui/async-await/in-trait/missing-send-bound.stderr
@@ -21,5 +21,5 @@ LL -     async fn bar();
 LL +     fn bar() -> impl std::future::Future<Output = ()> + Send;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/in-trait/object-safety.stderr b/tests/ui/async-await/in-trait/object-safety.stderr
index 5b9fd98ac60..f45e6a2c8bb 100644
--- a/tests/ui/async-await/in-trait/object-safety.stderr
+++ b/tests/ui/async-await/in-trait/object-safety.stderr
@@ -13,6 +13,6 @@ LL |     async fn foo(&self);
    |              ^^^ ...because method `foo` is `async`
    = help: consider moving `foo` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/async-await/in-trait/return-not-existing-type-wrapping-rpitit.stderr b/tests/ui/async-await/in-trait/return-not-existing-type-wrapping-rpitit.stderr
index a66dd13bb7a..84e0a643485 100644
--- a/tests/ui/async-await/in-trait/return-not-existing-type-wrapping-rpitit.stderr
+++ b/tests/ui/async-await/in-trait/return-not-existing-type-wrapping-rpitit.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Missing` in this scope
 LL |     fn bar() -> Wrapper<Missing<impl Sized>>;
    |                         ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/async-await/in-trait/return-type-suggestion.stderr b/tests/ui/async-await/in-trait/return-type-suggestion.stderr
index 363870619f0..4947b7fec9d 100644
--- a/tests/ui/async-await/in-trait/return-type-suggestion.stderr
+++ b/tests/ui/async-await/in-trait/return-type-suggestion.stderr
@@ -7,6 +7,6 @@ LL |         Ok(())
    = note: expected unit type `()`
                    found enum `Result<(), _>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/in-trait/send-on-foreign-async-fn-in-trait.stderr b/tests/ui/async-await/in-trait/send-on-foreign-async-fn-in-trait.stderr
index 482707351d7..dd38e205b03 100644
--- a/tests/ui/async-await/in-trait/send-on-foreign-async-fn-in-trait.stderr
+++ b/tests/ui/async-await/in-trait/send-on-foreign-async-fn-in-trait.stderr
@@ -18,6 +18,6 @@ note: required by a bound in `needs_send`
 LL |     fn needs_send(_: impl Send) {}
    |                           ^^^^ required by this bound in `needs_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/in-trait/unconstrained-impl-region.stderr b/tests/ui/async-await/in-trait/unconstrained-impl-region.stderr
index 2cb0da2e8bc..ef7e4ef0eb8 100644
--- a/tests/ui/async-await/in-trait/unconstrained-impl-region.stderr
+++ b/tests/ui/async-await/in-trait/unconstrained-impl-region.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a> Actor for () {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/async-await/in-trait/warn.stderr b/tests/ui/async-await/in-trait/warn.stderr
index d0278628c97..c741a23c6d5 100644
--- a/tests/ui/async-await/in-trait/warn.stderr
+++ b/tests/ui/async-await/in-trait/warn.stderr
@@ -16,5 +16,5 @@ LL -     async fn not_send();
 LL +     fn not_send() -> impl std::future::Future<Output = ()> + Send;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/incorrect-move-async-order-issue-79694.stderr b/tests/ui/async-await/incorrect-move-async-order-issue-79694.stderr
index 5367b986d2b..782fa4295fd 100644
--- a/tests/ui/async-await/incorrect-move-async-order-issue-79694.stderr
+++ b/tests/ui/async-await/incorrect-move-async-order-issue-79694.stderr
@@ -9,5 +9,5 @@ help: try switching the order
 LL |     let _ = async move { };
    |             ~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-101715.stderr b/tests/ui/async-await/issue-101715.stderr
index d161fb0c05e..f6af15c00d6 100644
--- a/tests/ui/async-await/issue-101715.stderr
+++ b/tests/ui/async-await/issue-101715.stderr
@@ -11,6 +11,6 @@ LL |         .await
    = note: () must be a future or must implement `IntoFuture` to be awaited
    = note: required for `()` to implement `IntoFuture`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/issue-108572.stderr b/tests/ui/async-await/issue-108572.stderr
index 588669092b0..6a80bc14910 100644
--- a/tests/ui/async-await/issue-108572.stderr
+++ b/tests/ui/async-await/issue-108572.stderr
@@ -12,6 +12,6 @@ LL ~     let mut pinned = std::pin::pin!(fut);
 LL ~     pinned.as_mut().poll(cx);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/async-await/issue-64130-1-sync.stderr b/tests/ui/async-await/issue-64130-1-sync.stderr
index 207e085d273..5428d7ef71b 100644
--- a/tests/ui/async-await/issue-64130-1-sync.stderr
+++ b/tests/ui/async-await/issue-64130-1-sync.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `is_sync`
 LL | fn is_sync<T: Sync>(t: T) { }
    |               ^^^^ required by this bound in `is_sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-64130-2-send.stderr b/tests/ui/async-await/issue-64130-2-send.stderr
index a433c76ae70..f05e954d2d7 100644
--- a/tests/ui/async-await/issue-64130-2-send.stderr
+++ b/tests/ui/async-await/issue-64130-2-send.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `is_send`
 LL | fn is_send<T: Send>(t: T) { }
    |               ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-64130-3-other.stderr b/tests/ui/async-await/issue-64130-3-other.stderr
index 4bbb7731b11..3ac30bdc23e 100644
--- a/tests/ui/async-await/issue-64130-3-other.stderr
+++ b/tests/ui/async-await/issue-64130-3-other.stderr
@@ -20,6 +20,6 @@ note: required by a bound in `is_qux`
 LL | fn is_qux<T: Qux>(t: T) {}
    |              ^^^ required by this bound in `is_qux`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/issue-64130-non-send-future-diags.stderr b/tests/ui/async-await/issue-64130-non-send-future-diags.stderr
index cb02fcf5ce7..d28807e223b 100644
--- a/tests/ui/async-await/issue-64130-non-send-future-diags.stderr
+++ b/tests/ui/async-await/issue-64130-non-send-future-diags.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `is_send`
 LL | fn is_send<T: Send>(t: T) { }
    |               ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-66387-if-without-else.stderr b/tests/ui/async-await/issue-66387-if-without-else.stderr
index 8155fcb56b6..17f9b88c600 100644
--- a/tests/ui/async-await/issue-66387-if-without-else.stderr
+++ b/tests/ui/async-await/issue-66387-if-without-else.stderr
@@ -9,6 +9,6 @@ LL | |     }
    = note: `if` expressions without `else` evaluate to `()`
    = help: consider adding an `else` block that evaluates to the expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0317`.
diff --git a/tests/ui/async-await/issue-67252-unnamed-future.stderr b/tests/ui/async-await/issue-67252-unnamed-future.stderr
index 069befa9121..e1c5a22967e 100644
--- a/tests/ui/async-await/issue-67252-unnamed-future.stderr
+++ b/tests/ui/async-await/issue-67252-unnamed-future.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `spawn`
 LL | fn spawn<T: Send>(_: T) {}
    |             ^^^^ required by this bound in `spawn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-67651.stderr b/tests/ui/async-await/issue-67651.stderr
index 89017f6cc3e..9047fa4f3fe 100644
--- a/tests/ui/async-await/issue-67651.stderr
+++ b/tests/ui/async-await/issue-67651.stderr
@@ -7,6 +7,6 @@ LL | impl From for () {
 LL | impl From for () {
    | ^^^^^^^^^^^^^^^^ conflicting implementation for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/async-await/issue-67765-async-diagnostic.stderr b/tests/ui/async-await/issue-67765-async-diagnostic.stderr
index 492e06fbbc0..833df51a7aa 100644
--- a/tests/ui/async-await/issue-67765-async-diagnostic.stderr
+++ b/tests/ui/async-await/issue-67765-async-diagnostic.stderr
@@ -7,6 +7,6 @@ LL |
 LL |     Err(b)?;
    |     ^^^^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/async-await/issue-68523-start.stderr b/tests/ui/async-await/issue-68523-start.stderr
index 7c06fe3400e..5b76ab56e24 100644
--- a/tests/ui/async-await/issue-68523-start.stderr
+++ b/tests/ui/async-await/issue-68523-start.stderr
@@ -4,6 +4,6 @@ error[E0752]: `#[start]` function is not allowed to be `async`
 LL | pub async fn start(_: isize, _: *const *const u8) -> isize {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `#[start]` is not allowed to be `async`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0752`.
diff --git a/tests/ui/async-await/issue-68523.stderr b/tests/ui/async-await/issue-68523.stderr
index dfdf078e303..ec3e2e96231 100644
--- a/tests/ui/async-await/issue-68523.stderr
+++ b/tests/ui/async-await/issue-68523.stderr
@@ -4,6 +4,6 @@ error[E0752]: `main` function is not allowed to be `async`
 LL | async fn main() -> Result<i32, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `main` function is not allowed to be `async`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0752`.
diff --git a/tests/ui/async-await/issue-69446-fnmut-capture.stderr b/tests/ui/async-await/issue-69446-fnmut-capture.stderr
index 3d2b0402bc5..0366c2f44c0 100644
--- a/tests/ui/async-await/issue-69446-fnmut-capture.stderr
+++ b/tests/ui/async-await/issue-69446-fnmut-capture.stderr
@@ -15,5 +15,5 @@ LL | |     });
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-70818.stderr b/tests/ui/async-await/issue-70818.stderr
index 20109d4d116..317c04d2c74 100644
--- a/tests/ui/async-await/issue-70818.stderr
+++ b/tests/ui/async-await/issue-70818.stderr
@@ -14,5 +14,5 @@ help: consider restricting type parameter `U`
 LL | fn foo<T: Send, U: std::marker::Send>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
    |                  +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-70935-complex-spans.stderr b/tests/ui/async-await/issue-70935-complex-spans.stderr
index d0605d7e1a6..14ef1cbb67c 100644
--- a/tests/ui/async-await/issue-70935-complex-spans.stderr
+++ b/tests/ui/async-await/issue-70935-complex-spans.stderr
@@ -36,6 +36,6 @@ LL | |         }).await;
 LL | |     }
    | |_____^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/issue-71137.stderr b/tests/ui/async-await/issue-71137.stderr
index 443af010c4a..8739c22a310 100644
--- a/tests/ui/async-await/issue-71137.stderr
+++ b/tests/ui/async-await/issue-71137.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `fake_spawn`
 LL | fn fake_spawn<F: Future + Send + 'static>(f: F) { }
    |                           ^^^^ required by this bound in `fake_spawn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-72442.stderr b/tests/ui/async-await/issue-72442.stderr
index 4a1705715ca..313f6079c7c 100644
--- a/tests/ui/async-await/issue-72442.stderr
+++ b/tests/ui/async-await/issue-72442.stderr
@@ -9,6 +9,6 @@ LL |             let mut f = File::open(path.to_str())?;
 note: required by a bound in `File::open`
   --> $SRC_DIR/std/src/fs.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/issue-73541-1.stderr b/tests/ui/async-await/issue-73541-1.stderr
index 80c1fdf002a..3fd60223542 100644
--- a/tests/ui/async-await/issue-73541-1.stderr
+++ b/tests/ui/async-await/issue-73541-1.stderr
@@ -9,6 +9,6 @@ LL |                 continue 'a
    |
    = note: labels are unreachable through functions, closures, async blocks and modules
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0767`.
diff --git a/tests/ui/async-await/issue-73541-2.stderr b/tests/ui/async-await/issue-73541-2.stderr
index 4c9741f6f37..584b71ce643 100644
--- a/tests/ui/async-await/issue-73541-2.stderr
+++ b/tests/ui/async-await/issue-73541-2.stderr
@@ -13,6 +13,6 @@ LL |                 b!();
    = note: labels are unreachable through functions, closures, async blocks and modules
    = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0767`.
diff --git a/tests/ui/async-await/issue-73541-3.stderr b/tests/ui/async-await/issue-73541-3.stderr
index 53487aaca99..baa41c2e822 100644
--- a/tests/ui/async-await/issue-73541-3.stderr
+++ b/tests/ui/async-await/issue-73541-3.stderr
@@ -7,6 +7,6 @@ LL |         || {
 LL |             loop { continue 'aaaaaa }
    |                             ^^^^^^^ undeclared label `'aaaaaa`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0426`.
diff --git a/tests/ui/async-await/issue-73541.stderr b/tests/ui/async-await/issue-73541.stderr
index 4bb466ff16c..6c3aac5ed3b 100644
--- a/tests/ui/async-await/issue-73541.stderr
+++ b/tests/ui/async-await/issue-73541.stderr
@@ -9,6 +9,6 @@ LL |             loop { continue 'a }
    |
    = note: labels are unreachable through functions, closures, async blocks and modules
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0767`.
diff --git a/tests/ui/async-await/issue-73741-type-err.stderr b/tests/ui/async-await/issue-73741-type-err.stderr
index 0b5343a98cf..9fafdb1ed39 100644
--- a/tests/ui/async-await/issue-73741-type-err.stderr
+++ b/tests/ui/async-await/issue-73741-type-err.stderr
@@ -6,6 +6,6 @@ LL |     1 = 2;
    |     |
    |     cannot assign to this expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0070`.
diff --git a/tests/ui/async-await/issue-74047.stderr b/tests/ui/async-await/issue-74047.stderr
index 6bdb9ded482..c2dfa050fc2 100644
--- a/tests/ui/async-await/issue-74047.stderr
+++ b/tests/ui/async-await/issue-74047.stderr
@@ -7,6 +7,6 @@ LL | impl TryFrom<OtherStream> for MyStream {}
    = help: implement the missing item: `type Error = /* Type */;`
    = help: implement the missing item: `fn try_from(_: OtherStream) -> Result<Self, <Self as TryFrom<OtherStream>>::Error> { todo!() }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/async-await/issue-74497-lifetime-in-opaque.stderr b/tests/ui/async-await/issue-74497-lifetime-in-opaque.stderr
index 4427014ae3b..1bdd6423e78 100644
--- a/tests/ui/async-await/issue-74497-lifetime-in-opaque.stderr
+++ b/tests/ui/async-await/issue-74497-lifetime-in-opaque.stderr
@@ -7,5 +7,5 @@ LL |     let _ = foo(|x| bar(x));
    |                  |return type of closure `impl Future<Output = ()>` contains a lifetime `'2`
    |                  has type `&'1 u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-75785-confusing-named-region.stderr b/tests/ui/async-await/issue-75785-confusing-named-region.stderr
index b69033a0eda..c7316b971f5 100644
--- a/tests/ui/async-await/issue-75785-confusing-named-region.stderr
+++ b/tests/ui/async-await/issue-75785-confusing-named-region.stderr
@@ -10,6 +10,6 @@ LL |     *x += 1;
 LL |     (&32, y)
    |     -------- returning this value requires that `*x` is borrowed for `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/async-await/issue-77993-2.stderr b/tests/ui/async-await/issue-77993-2.stderr
index 64b378f83fc..6c3ca750e0e 100644
--- a/tests/ui/async-await/issue-77993-2.stderr
+++ b/tests/ui/async-await/issue-77993-2.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `!`
 LL |     macro!();
    |          ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issue-86507.stderr b/tests/ui/async-await/issue-86507.stderr
index d5a3f72cf25..0398e57ef78 100644
--- a/tests/ui/async-await/issue-86507.stderr
+++ b/tests/ui/async-await/issue-86507.stderr
@@ -19,5 +19,5 @@ help: consider further restricting this bound
 LL |     fn bar<'me, 'async_trait, T: Send + std::marker::Sync>(x: &'me T)
    |                                       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/issues/issue-102206.stderr b/tests/ui/async-await/issues/issue-102206.stderr
index cd845056805..19c70e8743a 100644
--- a/tests/ui/async-await/issues/issue-102206.stderr
+++ b/tests/ui/async-await/issues/issue-102206.stderr
@@ -13,6 +13,6 @@ help: consider borrowing here
 LL |     std::mem::size_of_val(&foo());
    |                           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/issues/issue-107280.stderr b/tests/ui/async-await/issues/issue-107280.stderr
index c5fd5c5bf0a..d1d80ce038c 100644
--- a/tests/ui/async-await/issues/issue-107280.stderr
+++ b/tests/ui/async-await/issues/issue-107280.stderr
@@ -16,6 +16,6 @@ help: add missing generic argument
 LL |     inner::<false, PING>().await
    |                  ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/async-await/issues/issue-112225-2.stderr b/tests/ui/async-await/issues/issue-112225-2.stderr
index 5926a4f3995..c44ad583d92 100644
--- a/tests/ui/async-await/issues/issue-112225-2.stderr
+++ b/tests/ui/async-await/issues/issue-112225-2.stderr
@@ -12,6 +12,6 @@ help: consider giving `x` an explicit type
 LL |     let x: /* Type */ = Default::default();
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/async-await/issues/issue-51719.stderr b/tests/ui/async-await/issues/issue-51719.stderr
index 19cc339ec0a..3fa5c738c01 100644
--- a/tests/ui/async-await/issues/issue-51719.stderr
+++ b/tests/ui/async-await/issues/issue-51719.stderr
@@ -6,6 +6,6 @@ LL |     let _gen = || foo().await;
    |                |
    |                this is not `async`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0728`.
diff --git a/tests/ui/async-await/issues/issue-51751.stderr b/tests/ui/async-await/issues/issue-51751.stderr
index 6dd3726608b..ba256b19948 100644
--- a/tests/ui/async-await/issues/issue-51751.stderr
+++ b/tests/ui/async-await/issues/issue-51751.stderr
@@ -7,6 +7,6 @@ LL |     let result = inc(10000);
 LL |     let finished = result.await;
    |                           ^^^^^ only allowed inside `async` functions and blocks
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0728`.
diff --git a/tests/ui/async-await/issues/issue-61187.stderr b/tests/ui/async-await/issues/issue-61187.stderr
index 203b17550a0..59c6a4e493a 100644
--- a/tests/ui/async-await/issues/issue-61187.stderr
+++ b/tests/ui/async-await/issues/issue-61187.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL | async fn response(mut data: Vec<u8>) {
    |                   +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/async-await/issues/issue-62009-2.stderr b/tests/ui/async-await/issues/issue-62009-2.stderr
index 9c2f20df657..80a831cc547 100644
--- a/tests/ui/async-await/issues/issue-62009-2.stderr
+++ b/tests/ui/async-await/issues/issue-62009-2.stderr
@@ -6,6 +6,6 @@ LL | fn main() {
 LL |     (async || 2333)().await;
    |                       ^^^^^ only allowed inside `async` functions and blocks
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0728`.
diff --git a/tests/ui/async-await/issues/issue-63388-1.stderr b/tests/ui/async-await/issues/issue-63388-1.stderr
index 88542315ec0..f7f285ad0cc 100644
--- a/tests/ui/async-await/issues/issue-63388-1.stderr
+++ b/tests/ui/async-await/issues/issue-63388-1.stderr
@@ -10,6 +10,6 @@ LL | |         foo
 LL | |     }
    | |_____^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/async-await/issues/issue-65159.stderr b/tests/ui/async-await/issues/issue-65159.stderr
index b8741333c32..19512116a66 100644
--- a/tests/ui/async-await/issues/issue-65159.stderr
+++ b/tests/ui/async-await/issues/issue-65159.stderr
@@ -11,6 +11,6 @@ help: add missing generic argument
 LL | async fn copy() -> Result<(), E>
    |                             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/async-await/issues/issue-66958-non-copy-infered-type-arg.stderr b/tests/ui/async-await/issues/issue-66958-non-copy-infered-type-arg.stderr
index e2a73539874..3fb504a0e3a 100644
--- a/tests/ui/async-await/issues/issue-66958-non-copy-infered-type-arg.stderr
+++ b/tests/ui/async-await/issues/issue-66958-non-copy-infered-type-arg.stderr
@@ -8,6 +8,6 @@ LL |         Self::full(self);
    |
    = note: partial move occurs because `self.0` has type `S`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/async-await/issues/issue-67893.stderr b/tests/ui/async-await/issues/issue-67893.stderr
index 2a712aee9c4..90c1e976dce 100644
--- a/tests/ui/async-await/issues/issue-67893.stderr
+++ b/tests/ui/async-await/issues/issue-67893.stderr
@@ -28,6 +28,6 @@ note: required by a bound in `g`
 LL | fn g(_: impl Send) {}
    |              ^^^^ required by this bound in `g`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/issues/issue-72312.stderr b/tests/ui/async-await/issues/issue-72312.stderr
index 679272858bd..cd93f8a3c55 100644
--- a/tests/ui/async-await/issues/issue-72312.stderr
+++ b/tests/ui/async-await/issues/issue-72312.stderr
@@ -18,6 +18,6 @@ LL | |         });
    | |__________`self` escapes the method body here
    |            argument requires that `'1` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/async-await/issues/issue-78938-async-block.stderr b/tests/ui/async-await/issues/issue-78938-async-block.stderr
index c1a4b467f10..dc373a24f6f 100644
--- a/tests/ui/async-await/issues/issue-78938-async-block.stderr
+++ b/tests/ui/async-await/issues/issue-78938-async-block.stderr
@@ -14,6 +14,6 @@ help: to force the async block to take ownership of `room_ref` (and any other re
 LL |     let gameloop_handle = spawn(async move {
    |                                       ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/async-await/issues/non-async-enclosing-span.stderr b/tests/ui/async-await/issues/non-async-enclosing-span.stderr
index b6583022c16..91a9e5aa6ca 100644
--- a/tests/ui/async-await/issues/non-async-enclosing-span.stderr
+++ b/tests/ui/async-await/issues/non-async-enclosing-span.stderr
@@ -7,6 +7,6 @@ LL |     let x = move || {};
 LL |     let y = do_the_thing().await;
    |                            ^^^^^ only allowed inside `async` functions and blocks
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0728`.
diff --git a/tests/ui/async-await/no-const-async.stderr b/tests/ui/async-await/no-const-async.stderr
index 90ec646c8c0..29095f3c4d2 100644
--- a/tests/ui/async-await/no-const-async.stderr
+++ b/tests/ui/async-await/no-const-async.stderr
@@ -7,5 +7,5 @@ LL | pub const async fn x() {}
    |     |     `async` because of this
    |     `const` because of this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/no-move-across-await-struct.stderr b/tests/ui/async-await/no-move-across-await-struct.stderr
index 4eaed1cf155..ddc9bde59ad 100644
--- a/tests/ui/async-await/no-move-across-await-struct.stderr
+++ b/tests/ui/async-await/no-move-across-await-struct.stderr
@@ -8,6 +8,6 @@ LL |     s.x
    |
    = note: move occurs because `s.x` has type `Vec<usize>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/async-await/no-move-across-await-tuple.stderr b/tests/ui/async-await/no-move-across-await-tuple.stderr
index d750df9918e..61b492fe989 100644
--- a/tests/ui/async-await/no-move-across-await-tuple.stderr
+++ b/tests/ui/async-await/no-move-across-await-tuple.stderr
@@ -9,6 +9,6 @@ LL |     x.1
    |
    = note: move occurs because `x.1` has type `Vec<usize>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/async-await/no-non-guaranteed-initialization.stderr b/tests/ui/async-await/no-non-guaranteed-initialization.stderr
index 12c15bf56ce..7adccdba2f8 100644
--- a/tests/ui/async-await/no-non-guaranteed-initialization.stderr
+++ b/tests/ui/async-await/no-non-guaranteed-initialization.stderr
@@ -11,6 +11,6 @@ LL |     }
 LL |     y
    |     ^ `y` used here but it is possibly-uninitialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/async-await/no-params-non-move-async-closure.stderr b/tests/ui/async-await/no-params-non-move-async-closure.stderr
index 1f589c516a9..d2659553699 100644
--- a/tests/ui/async-await/no-params-non-move-async-closure.stderr
+++ b/tests/ui/async-await/no-params-non-move-async-closure.stderr
@@ -6,6 +6,6 @@ LL |     let _ = async |x: u8| {};
    |
    = help: consider using `let` statements to manually capture variables by reference before entering an `async move` closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0708`.
diff --git a/tests/ui/async-await/partial-drop-partial-reinit.stderr b/tests/ui/async-await/partial-drop-partial-reinit.stderr
index 310a2923955..f088b118730 100644
--- a/tests/ui/async-await/partial-drop-partial-reinit.stderr
+++ b/tests/ui/async-await/partial-drop-partial-reinit.stderr
@@ -30,6 +30,6 @@ note: required by a bound in `gimme_send`
 LL | fn gimme_send<T: Send>(t: T) {
    |                  ^^^^ required by this bound in `gimme_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/pin-needed-to-poll-2.stderr b/tests/ui/async-await/pin-needed-to-poll-2.stderr
index 61126faf899..9c1ad32cc2c 100644
--- a/tests/ui/async-await/pin-needed-to-poll-2.stderr
+++ b/tests/ui/async-await/pin-needed-to-poll-2.stderr
@@ -16,6 +16,6 @@ LL | struct Sleep(std::marker::PhantomPinned);
 note: required by a bound in `Pin::<P>::new`
   --> $SRC_DIR/core/src/pin.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/pin-needed-to-poll.stderr b/tests/ui/async-await/pin-needed-to-poll.stderr
index 964709daeda..e576cd6c7a4 100644
--- a/tests/ui/async-await/pin-needed-to-poll.stderr
+++ b/tests/ui/async-await/pin-needed-to-poll.stderr
@@ -13,6 +13,6 @@ LL ~         let mut pinned = std::pin::pin!(self.sleep);
 LL ~         pinned.as_mut().poll(cx)
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/async-await/proper-span-for-type-error.stderr b/tests/ui/async-await/proper-span-for-type-error.stderr
index 592ef7faf81..2c72a8eb5f6 100644
--- a/tests/ui/async-await/proper-span-for-type-error.stderr
+++ b/tests/ui/async-await/proper-span-for-type-error.stderr
@@ -12,6 +12,6 @@ LL ~     a().await;
 LL ~     Ok(())
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/recursive-async-impl-trait-type.stderr b/tests/ui/async-await/recursive-async-impl-trait-type.stderr
index 64917329c49..969258f84ed 100644
--- a/tests/ui/async-await/recursive-async-impl-trait-type.stderr
+++ b/tests/ui/async-await/recursive-async-impl-trait-type.stderr
@@ -7,6 +7,6 @@ LL | async fn recursive_async_function() -> () {
    = note: a recursive `async fn` must be rewritten to return a boxed `dyn Future`
    = note: consider using the `async_recursion` crate: https://crates.io/crates/async_recursion
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0733`.
diff --git a/tests/ui/async-await/return-type-notation/normalizing-self-auto-trait-issue-109924.current.stderr b/tests/ui/async-await/return-type-notation/normalizing-self-auto-trait-issue-109924.current.stderr
index 6a47f1ab983..d2db6abe313 100644
--- a/tests/ui/async-await/return-type-notation/normalizing-self-auto-trait-issue-109924.current.stderr
+++ b/tests/ui/async-await/return-type-notation/normalizing-self-auto-trait-issue-109924.current.stderr
@@ -30,6 +30,6 @@ note: required by a bound in `build`
 LL | fn build<T>(_: T) where T: Foo<bar(): Send> {}
    |                                       ^^^^ required by this bound in `build`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/return-type-notation/rtn-in-impl-signature.stderr b/tests/ui/async-await/return-type-notation/rtn-in-impl-signature.stderr
index 52d8168c9d8..4321d876e16 100644
--- a/tests/ui/async-await/return-type-notation/rtn-in-impl-signature.stderr
+++ b/tests/ui/async-await/return-type-notation/rtn-in-impl-signature.stderr
@@ -13,6 +13,6 @@ error[E0229]: associated type bindings are not allowed here
 LL | impl Super1<'_, bar(): Send> for () {}
    |                 ^^^^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/async-await/return-type-notation/super-method-bound-ambig.stderr b/tests/ui/async-await/return-type-notation/super-method-bound-ambig.stderr
index d9caab5875a..7eaf3b82d98 100644
--- a/tests/ui/async-await/return-type-notation/super-method-bound-ambig.stderr
+++ b/tests/ui/async-await/return-type-notation/super-method-bound-ambig.stderr
@@ -15,5 +15,5 @@ LL |     T: Foo<test(): Send>,
    |
    = note: `test` is declared in two supertraits: `Super2` and `Super1<'a>`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/async-await/suggest-missing-await-closure.stderr b/tests/ui/async-await/suggest-missing-await-closure.stderr
index d44af5b8dd8..47af270a03a 100644
--- a/tests/ui/async-await/suggest-missing-await-closure.stderr
+++ b/tests/ui/async-await/suggest-missing-await-closure.stderr
@@ -21,6 +21,6 @@ help: consider `await`ing on the `Future`
 LL |         take_u32(x.await)
    |                   ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/unreachable-lint-1.stderr b/tests/ui/async-await/unreachable-lint-1.stderr
index e9325788961..061cc7246a7 100644
--- a/tests/ui/async-await/unreachable-lint-1.stderr
+++ b/tests/ui/async-await/unreachable-lint-1.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/async-await/unresolved_type_param.stderr b/tests/ui/async-await/unresolved_type_param.stderr
index 45aa766065e..b9fb9832086 100644
--- a/tests/ui/async-await/unresolved_type_param.stderr
+++ b/tests/ui/async-await/unresolved_type_param.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     bar::<T>().await;
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/async-await/unsized-across-await.stderr b/tests/ui/async-await/unsized-across-await.stderr
index 649b12ce5a5..5bb2b7f4791 100644
--- a/tests/ui/async-await/unsized-across-await.stderr
+++ b/tests/ui/async-await/unsized-across-await.stderr
@@ -16,6 +16,6 @@ LL |     let _x = *x;
    = help: the trait `Sized` is not implemented for `dyn std::fmt::Display`
    = note: all values live across `await` must have a statically known size
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/attr-bad-crate-attr.stderr b/tests/ui/attr-bad-crate-attr.stderr
index ff420eeea4a..9df991f71b3 100644
--- a/tests/ui/attr-bad-crate-attr.stderr
+++ b/tests/ui/attr-bad-crate-attr.stderr
@@ -4,5 +4,5 @@ error: expected item after attributes
 LL | #[attr = "val"] // Unterminated
    | ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/attr-eq-token-tree.stderr b/tests/ui/attributes/attr-eq-token-tree.stderr
index 1846444b668..d642e168e18 100644
--- a/tests/ui/attributes/attr-eq-token-tree.stderr
+++ b/tests/ui/attributes/attr-eq-token-tree.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `]`
 LL | #[my_attr = !]
    |              ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/attrs-with-no-formal-in-generics-1.stderr b/tests/ui/attributes/attrs-with-no-formal-in-generics-1.stderr
index 5b4f5222a2b..6377d27f493 100644
--- a/tests/ui/attributes/attrs-with-no-formal-in-generics-1.stderr
+++ b/tests/ui/attributes/attrs-with-no-formal-in-generics-1.stderr
@@ -4,5 +4,5 @@ error: trailing attribute after generic parameter
 LL | impl<#[rustc_dummy] 'a, 'b, #[oops]> RefIntPair<'a, 'b> {
    |                             ^^^^^^^ attributes must go before parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/attrs-with-no-formal-in-generics-2.stderr b/tests/ui/attributes/attrs-with-no-formal-in-generics-2.stderr
index fce3ff7de78..3224da58a85 100644
--- a/tests/ui/attributes/attrs-with-no-formal-in-generics-2.stderr
+++ b/tests/ui/attributes/attrs-with-no-formal-in-generics-2.stderr
@@ -4,5 +4,5 @@ error: trailing attribute after generic parameter
 LL | impl<#[rustc_dummy] 'a, #[rustc_dummy] T, #[oops]> RefAny<'a, T> {}
    |                                           ^^^^^^^ attributes must go before parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/attrs-with-no-formal-in-generics-3.stderr b/tests/ui/attributes/attrs-with-no-formal-in-generics-3.stderr
index b9ca0097467..996df10a721 100644
--- a/tests/ui/attributes/attrs-with-no-formal-in-generics-3.stderr
+++ b/tests/ui/attributes/attrs-with-no-formal-in-generics-3.stderr
@@ -4,5 +4,5 @@ error: trailing attribute after generic parameter
 LL |     where Q: for <#[allow(unused)] 'a, 'b, #[oops]> Fn(RefIntPair<'a,'b>) -> &'b u32
    |                                            ^^^^^^^ attributes must go before parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/doc-test-literal.stderr b/tests/ui/attributes/doc-test-literal.stderr
index ebee09994ba..ed2964825c7 100644
--- a/tests/ui/attributes/doc-test-literal.stderr
+++ b/tests/ui/attributes/doc-test-literal.stderr
@@ -13,5 +13,5 @@ LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(invalid_doc_attributes)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/extented-attribute-macro-error.stderr b/tests/ui/attributes/extented-attribute-macro-error.stderr
index 0fcde9b7cc6..884f3c7b166 100644
--- a/tests/ui/attributes/extented-attribute-macro-error.stderr
+++ b/tests/ui/attributes/extented-attribute-macro-error.stderr
@@ -6,5 +6,5 @@ LL | #![doc = include_str!("../not_existing_file.md")]
    |
    = note: this error originates in the macro `include_str` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/invalid-repr.stderr b/tests/ui/attributes/invalid-repr.stderr
index 98a6a24b3c4..681460ad081 100644
--- a/tests/ui/attributes/invalid-repr.stderr
+++ b/tests/ui/attributes/invalid-repr.stderr
@@ -7,6 +7,6 @@ LL |
 LL | pub type Foo = i32;
    | ------------------- not a struct, enum, function, associated function, or union
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0517`.
diff --git a/tests/ui/attributes/issue-100631.stderr b/tests/ui/attributes/issue-100631.stderr
index caa5351ddc7..6e8e4f3b418 100644
--- a/tests/ui/attributes/issue-100631.stderr
+++ b/tests/ui/attributes/issue-100631.stderr
@@ -7,6 +7,6 @@ LL | #[repr(C)]
 LL | enum Foo {}
    | -------- zero-variant enum
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0084`.
diff --git a/tests/ui/attributes/key-value-expansion-on-mac.stderr b/tests/ui/attributes/key-value-expansion-on-mac.stderr
index 64ab892d997..7d817da1362 100644
--- a/tests/ui/attributes/key-value-expansion-on-mac.stderr
+++ b/tests/ui/attributes/key-value-expansion-on-mac.stderr
@@ -4,5 +4,5 @@ error: unexpected expression: `stringify!(b)`
 LL | #[rustc_dummy = stringify!(b)]
    |                 ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/key-value-non-ascii.stderr b/tests/ui/attributes/key-value-non-ascii.stderr
index 23d482de6a8..cc01bc46ebd 100644
--- a/tests/ui/attributes/key-value-non-ascii.stderr
+++ b/tests/ui/attributes/key-value-non-ascii.stderr
@@ -9,5 +9,5 @@ help: if you meant to use the UTF-8 encoding of 'ffi', use \xHH escapes
 LL | #[rustc_dummy = b"/xEF/xAC/x83.rs"]
    |                   ~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/macro_export_on_decl_macro.stderr b/tests/ui/attributes/macro_export_on_decl_macro.stderr
index 565e07919bc..10b86da4fd9 100644
--- a/tests/ui/attributes/macro_export_on_decl_macro.stderr
+++ b/tests/ui/attributes/macro_export_on_decl_macro.stderr
@@ -12,5 +12,5 @@ LL | #![deny(unused)]
    |         ^^^^^^
    = note: `#[deny(unused_attributes)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/main-removed-1.stderr b/tests/ui/attributes/main-removed-1.stderr
index 2422c5c3b62..fda28772e42 100644
--- a/tests/ui/attributes/main-removed-1.stderr
+++ b/tests/ui/attributes/main-removed-1.stderr
@@ -6,5 +6,5 @@ LL | #[main]
    |
    = note: `main` is in scope, but it is a function, not an attribute
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/no-mangle-closure.stderr b/tests/ui/attributes/no-mangle-closure.stderr
index 949eb70510e..c183783493b 100644
--- a/tests/ui/attributes/no-mangle-closure.stderr
+++ b/tests/ui/attributes/no-mangle-closure.stderr
@@ -4,5 +4,5 @@ error: `#[no_mangle]` cannot be used on a closure as it has no name
 LL |     (#[no_mangle] || y.0[0])()
    |      ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-crate.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-crate.stderr
index 225b8e8f32f..1666f4a3ee8 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-crate.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-crate.stderr
@@ -13,5 +13,5 @@ LL - #![unix_sigpipe = "inherit"]
 LL + #[unix_sigpipe = "inherit"]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-duplicates.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-duplicates.stderr
index 2362c17a090..931aae96b0f 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-duplicates.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-duplicates.stderr
@@ -10,5 +10,5 @@ note: attribute also specified here
 LL | #[unix_sigpipe = "sig_ign"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-list.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-list.stderr
index 59a87e13918..b1d79d7c2a2 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-list.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-list.stderr
@@ -11,5 +11,5 @@ LL | #[unix_sigpipe = "inherit|sig_ign|sig_dfl"]
 LL | #[unix_sigpipe]
    | ~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-main-fn.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-main-fn.stderr
index c4b81118c9f..124141b6552 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-main-fn.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-main-fn.stderr
@@ -4,5 +4,5 @@ error: `unix_sigpipe` attribute can only be used on `fn main()`
 LL | #[unix_sigpipe = "inherit"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-root-main.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-root-main.stderr
index a04f605edc2..346d83fa664 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-root-main.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-non-root-main.stderr
@@ -4,5 +4,5 @@ error: `unix_sigpipe` attribute can only be used on root `fn main()`
 LL |     #[unix_sigpipe = "inherit"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-start.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-start.stderr
index 2c9ce479b6c..9f691e396bd 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-start.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-start.stderr
@@ -4,5 +4,5 @@ error: `unix_sigpipe` attribute can only be used on `fn main()`
 LL | #[unix_sigpipe = "inherit"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-struct.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-struct.stderr
index c56ee60bb2e..d5eec9424c8 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-struct.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-struct.stderr
@@ -4,5 +4,5 @@ error: `unix_sigpipe` attribute can only be used on `fn main()`
 LL | #[unix_sigpipe = "inherit"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-wrong.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-wrong.stderr
index a66e45aa210..d750443e4a9 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe-wrong.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe-wrong.stderr
@@ -4,5 +4,5 @@ error: valid values for `#[unix_sigpipe = "..."]` are `inherit`, `sig_ign`, or `
 LL | #[unix_sigpipe = "wrong"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/unix_sigpipe/unix_sigpipe.stderr b/tests/ui/attributes/unix_sigpipe/unix_sigpipe.stderr
index 1b1eda825aa..b18ec9abc37 100644
--- a/tests/ui/attributes/unix_sigpipe/unix_sigpipe.stderr
+++ b/tests/ui/attributes/unix_sigpipe/unix_sigpipe.stderr
@@ -4,5 +4,5 @@ error: valid values for `#[unix_sigpipe = "..."]` are `inherit`, `sig_ign`, or `
 LL | #[unix_sigpipe]
    | ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/attributes/used_with_multi_args.stderr b/tests/ui/attributes/used_with_multi_args.stderr
index c93aafcfc7c..d4417a202d5 100644
--- a/tests/ui/attributes/used_with_multi_args.stderr
+++ b/tests/ui/attributes/used_with_multi_args.stderr
@@ -4,5 +4,5 @@ error: expected `used`, `used(compiler)` or `used(linker)`
 LL | #[used(compiler, linker)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/auto-traits/bad-generics-on-dyn.stderr b/tests/ui/auto-traits/bad-generics-on-dyn.stderr
index ade69ced606..06c7cbcd76d 100644
--- a/tests/ui/auto-traits/bad-generics-on-dyn.stderr
+++ b/tests/ui/auto-traits/bad-generics-on-dyn.stderr
@@ -6,6 +6,6 @@ LL | auto trait Trait1<'a> {}
    |            |
    |            auto trait cannot have generic parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0567`.
diff --git a/tests/ui/auto-traits/has-arguments.stderr b/tests/ui/auto-traits/has-arguments.stderr
index 3bba74badbc..b8a680e6a5c 100644
--- a/tests/ui/auto-traits/has-arguments.stderr
+++ b/tests/ui/auto-traits/has-arguments.stderr
@@ -6,6 +6,6 @@ LL | auto trait Trait1<'outer> {}
    |            |
    |            auto trait cannot have generic parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0567`.
diff --git a/tests/ui/auto-traits/issue-23080-2.current.stderr b/tests/ui/auto-traits/issue-23080-2.current.stderr
index a57c6d9b0cb..178bfff97d2 100644
--- a/tests/ui/auto-traits/issue-23080-2.current.stderr
+++ b/tests/ui/auto-traits/issue-23080-2.current.stderr
@@ -6,6 +6,6 @@ LL | unsafe auto trait Trait {
 LL |     type Output;
    |     -----^^^^^^- help: remove these associated items
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0380`.
diff --git a/tests/ui/auto-traits/issue-23080-2.next.stderr b/tests/ui/auto-traits/issue-23080-2.next.stderr
index a57c6d9b0cb..178bfff97d2 100644
--- a/tests/ui/auto-traits/issue-23080-2.next.stderr
+++ b/tests/ui/auto-traits/issue-23080-2.next.stderr
@@ -6,6 +6,6 @@ LL | unsafe auto trait Trait {
 LL |     type Output;
    |     -----^^^^^^- help: remove these associated items
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0380`.
diff --git a/tests/ui/auto-traits/issue-23080.stderr b/tests/ui/auto-traits/issue-23080.stderr
index f5d607298b7..5cea45060c8 100644
--- a/tests/ui/auto-traits/issue-23080.stderr
+++ b/tests/ui/auto-traits/issue-23080.stderr
@@ -9,6 +9,6 @@ LL | |         println!("Hello");
 LL | |     }
    | |_____- help: remove these associated items
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0380`.
diff --git a/tests/ui/auto-traits/issue-83857-ub.stderr b/tests/ui/auto-traits/issue-83857-ub.stderr
index 23a2f62d905..80f9330eb81 100644
--- a/tests/ui/auto-traits/issue-83857-ub.stderr
+++ b/tests/ui/auto-traits/issue-83857-ub.stderr
@@ -17,6 +17,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn generic<T, U>(v: Foo<T, U>, f: fn(<Foo<T, U> as WithAssoc>::Output) -> i32) where Foo<T, U>: Send {
    |                                                                                +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/auto-traits/issue-84075.stderr b/tests/ui/auto-traits/issue-84075.stderr
index 6fbdc669b6f..943d521ce9e 100644
--- a/tests/ui/auto-traits/issue-84075.stderr
+++ b/tests/ui/auto-traits/issue-84075.stderr
@@ -6,6 +6,6 @@ LL | auto trait Magic where Self: Copy {}
    |            |
    |            auto traits cannot have super traits or lifetime bounds
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0568`.
diff --git a/tests/ui/auto-traits/str-contains-slice-conceptually.stderr b/tests/ui/auto-traits/str-contains-slice-conceptually.stderr
index 1cf16cebddd..e1dae35be00 100644
--- a/tests/ui/auto-traits/str-contains-slice-conceptually.stderr
+++ b/tests/ui/auto-traits/str-contains-slice-conceptually.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `needs_auto_trait`
 LL | fn needs_auto_trait<T: AutoTrait + ?Sized>() {}
    |                        ^^^^^^^^^ required by this bound in `needs_auto_trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr
index 80f07410381..23aae13639c 100644
--- a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr
+++ b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr
@@ -6,6 +6,6 @@ LL | auto trait Magic: Copy {}
    |            |
    |            auto traits cannot have super traits or lifetime bounds
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0568`.
diff --git a/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types-2.stderr b/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types-2.stderr
index 0c4970a7259..aa5585a5371 100644
--- a/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types-2.stderr
+++ b/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types-2.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `is_mytrait`
 LL | fn is_mytrait<T: MyTrait>() {}
    |                  ^^^^^^^ required by this bound in `is_mytrait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types.stderr b/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types.stderr
index c575c485a85..668cbc8aeb4 100644
--- a/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types.stderr
+++ b/tests/ui/auto-traits/typeck-default-trait-impl-constituent-types.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `is_mytrait`
 LL | fn is_mytrait<T: MyTrait>() {}
    |                  ^^^^^^^ required by this bound in `is_mytrait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/auto-traits/typeck-default-trait-impl-precedence.stderr b/tests/ui/auto-traits/typeck-default-trait-impl-precedence.stderr
index bd7aaf6fb6d..2498af996ea 100644
--- a/tests/ui/auto-traits/typeck-default-trait-impl-precedence.stderr
+++ b/tests/ui/auto-traits/typeck-default-trait-impl-precedence.stderr
@@ -22,6 +22,6 @@ LL -     is_defaulted::<&'static u32>();
 LL +     is_defaulted::<u32>();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr b/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr
index 06a7e90858c..19c3c641819 100644
--- a/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr
+++ b/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr
@@ -12,6 +12,6 @@ help: consider giving `var_fn` an explicit type, where the placeholders `_` are
 LL |     let var_fn: Value<Rc<_>> = Value::wrap();
    |               ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/binding/const-param.stderr b/tests/ui/binding/const-param.stderr
index adda80810ea..e68893a59e4 100644
--- a/tests/ui/binding/const-param.stderr
+++ b/tests/ui/binding/const-param.stderr
@@ -4,6 +4,6 @@ error[E0158]: const parameters cannot be referenced in patterns
 LL |         N => {}
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0158`.
diff --git a/tests/ui/binop/binary-op-on-double-ref.stderr b/tests/ui/binop/binary-op-on-double-ref.stderr
index 2e8aeebc681..d1d1d770765 100644
--- a/tests/ui/binop/binary-op-on-double-ref.stderr
+++ b/tests/ui/binop/binary-op-on-double-ref.stderr
@@ -11,6 +11,6 @@ help: `%` can be used on `&{integer}` if you dereference the left-hand side
 LL |         *x % 2 == 0
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/binary-op-suggest-deref.stderr b/tests/ui/binop/binary-op-suggest-deref.stderr
index 1b7e45c7724..d1d0089ece7 100644
--- a/tests/ui/binop/binary-op-suggest-deref.stderr
+++ b/tests/ui/binop/binary-op-suggest-deref.stderr
@@ -9,6 +9,6 @@ help: consider dereferencing the borrow
 LL |     if *i < 0 {}
    |        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/binop/binop-bitxor-str.stderr b/tests/ui/binop/binop-bitxor-str.stderr
index f236cd61efe..20b1ecc5a93 100644
--- a/tests/ui/binop/binop-bitxor-str.stderr
+++ b/tests/ui/binop/binop-bitxor-str.stderr
@@ -6,6 +6,6 @@ LL | fn main() { let x = "a".to_string() ^ "b".to_string(); }
    |                     |
    |                     String
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/binop-mul-bool.stderr b/tests/ui/binop/binop-mul-bool.stderr
index 8b5cde63c99..82d066f45a4 100644
--- a/tests/ui/binop/binop-mul-bool.stderr
+++ b/tests/ui/binop/binop-mul-bool.stderr
@@ -6,6 +6,6 @@ LL | fn main() { let x = true * false; }
    |                     |
    |                     bool
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/binop-mul-i32-f32.stderr b/tests/ui/binop/binop-mul-i32-f32.stderr
index 115e7000619..6ed3e7b4447 100644
--- a/tests/ui/binop/binop-mul-i32-f32.stderr
+++ b/tests/ui/binop/binop-mul-i32-f32.stderr
@@ -11,6 +11,6 @@ LL |     x * y
              <&'a i32 as Mul<i32>>
              <&i32 as Mul<&i32>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/binop/binop-typeck.stderr b/tests/ui/binop/binop-typeck.stderr
index 42d91081999..da7f3182826 100644
--- a/tests/ui/binop/binop-typeck.stderr
+++ b/tests/ui/binop/binop-typeck.stderr
@@ -6,6 +6,6 @@ LL |     let z = x + y;
    |             |
    |             bool
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/eq-arr.stderr b/tests/ui/binop/eq-arr.stderr
index a22f8e3ab0c..afcfb7b288b 100644
--- a/tests/ui/binop/eq-arr.stderr
+++ b/tests/ui/binop/eq-arr.stderr
@@ -17,6 +17,6 @@ LL +     #[derive(PartialEq)]
 LL |     struct X;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/eq-vec.stderr b/tests/ui/binop/eq-vec.stderr
index 0a98cddfe05..14739752877 100644
--- a/tests/ui/binop/eq-vec.stderr
+++ b/tests/ui/binop/eq-vec.stderr
@@ -19,6 +19,6 @@ LL +     #[derive(PartialEq)]
 LL |     enum Foo {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/false-binop-caused-by-missing-semi.stderr b/tests/ui/binop/false-binop-caused-by-missing-semi.stderr
index fca042b1c57..eeb6b028a9a 100644
--- a/tests/ui/binop/false-binop-caused-by-missing-semi.stderr
+++ b/tests/ui/binop/false-binop-caused-by-missing-semi.stderr
@@ -12,6 +12,6 @@ help: you might have meant to write a semicolon here
 LL |     foo();
    |          +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0070`.
diff --git a/tests/ui/binop/issue-3820.stderr b/tests/ui/binop/issue-3820.stderr
index cfa78a41dbf..7cce93dca09 100644
--- a/tests/ui/binop/issue-3820.stderr
+++ b/tests/ui/binop/issue-3820.stderr
@@ -14,6 +14,6 @@ LL | struct Thing {
 note: the trait `Mul` must be implemented
   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/issue-77910-2.stderr b/tests/ui/binop/issue-77910-2.stderr
index b3856b6ae16..e58ae0fad9b 100644
--- a/tests/ui/binop/issue-77910-2.stderr
+++ b/tests/ui/binop/issue-77910-2.stderr
@@ -11,6 +11,6 @@ help: use parentheses to call this function
 LL |     if foo(/* &i32 */) == y {}
    |           ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/issue-93927.stderr b/tests/ui/binop/issue-93927.stderr
index 75558b502f9..9bcf2b17357 100644
--- a/tests/ui/binop/issue-93927.stderr
+++ b/tests/ui/binop/issue-93927.stderr
@@ -11,6 +11,6 @@ help: consider further restricting this bound
 LL | fn cond<T: PartialEq + std::cmp::Eq>(val: MyType<T>) -> bool {
    |                      ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/binop/placement-syntax.stderr b/tests/ui/binop/placement-syntax.stderr
index 3fdaf4cd0f5..b20a2ee6353 100644
--- a/tests/ui/binop/placement-syntax.stderr
+++ b/tests/ui/binop/placement-syntax.stderr
@@ -9,5 +9,5 @@ help: if you meant to write a comparison against a negative value, add a space i
 LL |     if x< -1 {
    |         ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/blind/blind-item-block-item-shadow.stderr b/tests/ui/blind/blind-item-block-item-shadow.stderr
index 68b3f4c1ae2..2e24ef453c2 100644
--- a/tests/ui/blind/blind-item-block-item-shadow.stderr
+++ b/tests/ui/blind/blind-item-block-item-shadow.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL |         use foo::Bar as OtherBar;
    |             ~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/blind/blind-item-block-middle.stderr b/tests/ui/blind/blind-item-block-middle.stderr
index 63e6d76843d..b2ae169013a 100644
--- a/tests/ui/blind/blind-item-block-middle.stderr
+++ b/tests/ui/blind/blind-item-block-middle.stderr
@@ -11,6 +11,6 @@ LL |     let bar = 5;
    |         `bar` is interpreted as a unit struct, not a new binding
    |         help: introduce a new binding instead: `other_bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/blind/blind-item-item-shadow.stderr b/tests/ui/blind/blind-item-item-shadow.stderr
index 7f9e8008929..84b273c7338 100644
--- a/tests/ui/blind/blind-item-item-shadow.stderr
+++ b/tests/ui/blind/blind-item-item-shadow.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | use foo::foo as other_foo;
    |     ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/block-result/block-must-not-have-result-do.stderr b/tests/ui/block-result/block-must-not-have-result-do.stderr
index 914886f81b4..2a94f0a87e1 100644
--- a/tests/ui/block-result/block-must-not-have-result-do.stderr
+++ b/tests/ui/block-result/block-must-not-have-result-do.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |         true
    |         ^^^^ expected `()`, found `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/block-result/block-must-not-have-result-res.stderr b/tests/ui/block-result/block-must-not-have-result-res.stderr
index b7427462bcb..e075dc230d0 100644
--- a/tests/ui/block-result/block-must-not-have-result-res.stderr
+++ b/tests/ui/block-result/block-must-not-have-result-res.stderr
@@ -6,6 +6,6 @@ LL |     fn drop(&mut self) {
 LL |         true
    |         ^^^^ expected `()`, found `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/block-result/block-must-not-have-result-while.stderr b/tests/ui/block-result/block-must-not-have-result-while.stderr
index 7f96aa289d0..94a4b33da5d 100644
--- a/tests/ui/block-result/block-must-not-have-result-while.stderr
+++ b/tests/ui/block-result/block-must-not-have-result-while.stderr
@@ -16,6 +16,6 @@ LL | |
 LL | |     }
    | |_____- expected this to be `()`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/block-result/issue-11714.stderr b/tests/ui/block-result/issue-11714.stderr
index 42fb3d3d43d..25651328e9d 100644
--- a/tests/ui/block-result/issue-11714.stderr
+++ b/tests/ui/block-result/issue-11714.stderr
@@ -9,6 +9,6 @@ LL | fn blah() -> i32 {
 LL |     ;
    |     - help: remove this semicolon to return this value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/block-result/issue-3563.stderr b/tests/ui/block-result/issue-3563.stderr
index be551f6e889..c473a84413e 100644
--- a/tests/ui/block-result/issue-3563.stderr
+++ b/tests/ui/block-result/issue-3563.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `b` found for reference `&Self` in the current sco
 LL |         || self.b()
    |                 ^ help: there is a method with a similar name: `a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/block-result/issue-5500.stderr b/tests/ui/block-result/issue-5500.stderr
index 417991e9e0b..71ca8ffe2a8 100644
--- a/tests/ui/block-result/issue-5500.stderr
+++ b/tests/ui/block-result/issue-5500.stderr
@@ -14,6 +14,6 @@ LL -     &panic!()
 LL +     panic!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/block-result/unexpected-return-on-unit.stderr b/tests/ui/block-result/unexpected-return-on-unit.stderr
index 4acb955a8e7..0b79cf0da2a 100644
--- a/tests/ui/block-result/unexpected-return-on-unit.stderr
+++ b/tests/ui/block-result/unexpected-return-on-unit.stderr
@@ -13,6 +13,6 @@ help: try adding a return type
 LL | fn bar() -> usize {
    |          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/bogus-tag.stderr b/tests/ui/bogus-tag.stderr
index 899ff4261ba..d94bd489ec6 100644
--- a/tests/ui/bogus-tag.stderr
+++ b/tests/ui/bogus-tag.stderr
@@ -7,6 +7,6 @@ LL | enum Color { Rgb(isize, isize, isize), Rgba(isize, isize, isize, isize), }
 LL |         Color::Hsl(h, s, l) => { println!("hsl"); }
    |                ^^^ variant or associated item not found in `Color`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/borrowck/access-mode-in-closures.stderr b/tests/ui/borrowck/access-mode-in-closures.stderr
index abee72ba8cf..b9a45edb330 100644
--- a/tests/ui/borrowck/access-mode-in-closures.stderr
+++ b/tests/ui/borrowck/access-mode-in-closures.stderr
@@ -13,6 +13,6 @@ LL -         match *s { S(v) => v }
 LL +         match s { S(v) => v }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/alias-liveness/escaping-bounds-2.stderr b/tests/ui/borrowck/alias-liveness/escaping-bounds-2.stderr
index 7fd0cb9bb02..0cd6dfe7762 100644
--- a/tests/ui/borrowck/alias-liveness/escaping-bounds-2.stderr
+++ b/tests/ui/borrowck/alias-liveness/escaping-bounds-2.stderr
@@ -14,6 +14,6 @@ LL ~     let binding = String::new();
 LL ~     let func = get_func::<T>(&binding);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/alias-liveness/higher-ranked-outlives-for-capture.stderr b/tests/ui/borrowck/alias-liveness/higher-ranked-outlives-for-capture.stderr
index 58a42d8afe4..b5c2b662f31 100644
--- a/tests/ui/borrowck/alias-liveness/higher-ranked-outlives-for-capture.stderr
+++ b/tests/ui/borrowck/alias-liveness/higher-ranked-outlives-for-capture.stderr
@@ -11,6 +11,6 @@ LL | }
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr b/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr
index e1fbbc14f44..73de5864953 100644
--- a/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr
+++ b/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr
@@ -8,6 +8,6 @@ LL | fn foo<'a>(s: &'a str) -> impl Trait + 'static {
 LL |     bar(s)
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/borrowck/anonymous-region-in-apit.stderr b/tests/ui/borrowck/anonymous-region-in-apit.stderr
index 9e100f8ac3c..72dfbb797eb 100644
--- a/tests/ui/borrowck/anonymous-region-in-apit.stderr
+++ b/tests/ui/borrowck/anonymous-region-in-apit.stderr
@@ -11,6 +11,6 @@ LL |     |baz: &str| foo.bar(baz);
    |      |    let's call the lifetime of this reference `'1`
    |      `baz` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/borrowck/borrow-immutable-upvar-mutation-impl-trait.stderr b/tests/ui/borrowck/borrow-immutable-upvar-mutation-impl-trait.stderr
index 6235e0db0da..2b16206cd77 100644
--- a/tests/ui/borrowck/borrow-immutable-upvar-mutation-impl-trait.stderr
+++ b/tests/ui/borrowck/borrow-immutable-upvar-mutation-impl-trait.stderr
@@ -9,6 +9,6 @@ LL |     move || {
 LL |         x += 1;
    |         ^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/borrowck/borrowck-and-init.stderr b/tests/ui/borrowck/borrowck-and-init.stderr
index 5abf07a3118..37386f1c465 100644
--- a/tests/ui/borrowck/borrowck-and-init.stderr
+++ b/tests/ui/borrowck/borrowck-and-init.stderr
@@ -11,6 +11,6 @@ LL |     println!("{}", i);
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-anon-fields-struct.stderr b/tests/ui/borrowck/borrowck-anon-fields-struct.stderr
index 7a959fb6ec6..37e98732f1f 100644
--- a/tests/ui/borrowck/borrowck-anon-fields-struct.stderr
+++ b/tests/ui/borrowck/borrowck-anon-fields-struct.stderr
@@ -10,6 +10,6 @@ LL |         Y(ref mut b, _) => b
 LL |     *a += 1;
    |     ------- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/borrowck-anon-fields-tuple.stderr b/tests/ui/borrowck/borrowck-anon-fields-tuple.stderr
index 88a8867f5ee..b749779b948 100644
--- a/tests/ui/borrowck/borrowck-anon-fields-tuple.stderr
+++ b/tests/ui/borrowck/borrowck-anon-fields-tuple.stderr
@@ -10,6 +10,6 @@ LL |         (ref mut b, _) => b
 LL |     *a += 1;
    |     ------- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/borrowck-assign-to-constants.stderr b/tests/ui/borrowck/borrowck-assign-to-constants.stderr
index 864d933da12..82972b573c6 100644
--- a/tests/ui/borrowck/borrowck-assign-to-constants.stderr
+++ b/tests/ui/borrowck/borrowck-assign-to-constants.stderr
@@ -4,6 +4,6 @@ error[E0594]: cannot assign to immutable static item `foo`
 LL |     foo = 6;
    |     ^^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/borrowck/borrowck-auto-mut-ref-to-immut-var.stderr b/tests/ui/borrowck/borrowck-auto-mut-ref-to-immut-var.stderr
index 25d642c30dd..d14fbd76153 100644
--- a/tests/ui/borrowck/borrowck-auto-mut-ref-to-immut-var.stderr
+++ b/tests/ui/borrowck/borrowck-auto-mut-ref-to-immut-var.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut x = Foo { x: 3 };
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/borrowck-autoref-3261.stderr b/tests/ui/borrowck/borrowck-autoref-3261.stderr
index c2dfb687e8e..0e462256c5a 100644
--- a/tests/ui/borrowck/borrowck-autoref-3261.stderr
+++ b/tests/ui/borrowck/borrowck-autoref-3261.stderr
@@ -11,6 +11,6 @@ LL |         |opt| {
 LL |                     x = X(Either::Left((0, 0)));
    |                     - second borrow occurs due to use of `x` in closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/borrowck-block-uninit.stderr b/tests/ui/borrowck/borrowck-block-uninit.stderr
index 1a5969586f2..07c09f1f443 100644
--- a/tests/ui/borrowck/borrowck-block-uninit.stderr
+++ b/tests/ui/borrowck/borrowck-block-uninit.stderr
@@ -13,6 +13,6 @@ help: consider assigning a value
 LL |     let x: isize = 0;
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-borrow-from-temporary.stderr b/tests/ui/borrowck/borrowck-borrow-from-temporary.stderr
index 71bf052c93d..dabb5e21fd0 100644
--- a/tests/ui/borrowck/borrowck-borrow-from-temporary.stderr
+++ b/tests/ui/borrowck/borrowck-borrow-from-temporary.stderr
@@ -6,6 +6,6 @@ LL |     let &Foo(ref x) = &id(Foo(3));
 LL |     x
    |     ^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/borrowck/borrowck-borrow-immut-deref-of-box-as-mut.stderr b/tests/ui/borrowck/borrowck-borrow-immut-deref-of-box-as-mut.stderr
index a61fdbf6c8f..199f7c120d8 100644
--- a/tests/ui/borrowck/borrowck-borrow-immut-deref-of-box-as-mut.stderr
+++ b/tests/ui/borrowck/borrowck-borrow-immut-deref-of-box-as-mut.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut a: Box<_> = Box::new(A);
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/borrowck-borrow-mut-object-twice.stderr b/tests/ui/borrowck/borrowck-borrow-mut-object-twice.stderr
index fa0ae318e72..0bcf63d6af5 100644
--- a/tests/ui/borrowck/borrowck-borrow-mut-object-twice.stderr
+++ b/tests/ui/borrowck/borrowck-borrow-mut-object-twice.stderr
@@ -8,6 +8,6 @@ LL |     x.f2();
 LL |     y.use_ref();
    |     - first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue-2.stderr b/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue-2.stderr
index 6e112e27030..7f0ecf7b359 100644
--- a/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue-2.stderr
+++ b/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue-2.stderr
@@ -15,6 +15,6 @@ LL ~     let binding = vec!["Goodbye", "world!"];
 LL ~     let x = defer(&binding);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue.stderr b/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue.stderr
index 7ee840b34c5..5d6fc8fa7a3 100644
--- a/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue.stderr
+++ b/tests/ui/borrowck/borrowck-borrowed-uniq-rvalue.stderr
@@ -15,6 +15,6 @@ LL ~     let binding = Box::new(1);
 LL ~     buggy_map.insert(42, &*binding);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/borrowck-break-uninit-2.stderr b/tests/ui/borrowck/borrowck-break-uninit-2.stderr
index ea93a8f409c..7c0cda31c97 100644
--- a/tests/ui/borrowck/borrowck-break-uninit-2.stderr
+++ b/tests/ui/borrowck/borrowck-break-uninit-2.stderr
@@ -13,6 +13,6 @@ help: consider assigning a value
 LL |     let x: isize = 0;
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-break-uninit.stderr b/tests/ui/borrowck/borrowck-break-uninit.stderr
index a7a8fc2ff83..0d879c6fb7d 100644
--- a/tests/ui/borrowck/borrowck-break-uninit.stderr
+++ b/tests/ui/borrowck/borrowck-break-uninit.stderr
@@ -13,6 +13,6 @@ help: consider assigning a value
 LL |     let x: isize = 0;
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-closures-mut-of-mut.stderr b/tests/ui/borrowck/borrowck-closures-mut-of-mut.stderr
index e5ee5a40105..105a0b05189 100644
--- a/tests/ui/borrowck/borrowck-closures-mut-of-mut.stderr
+++ b/tests/ui/borrowck/borrowck-closures-mut-of-mut.stderr
@@ -13,6 +13,6 @@ LL |
 LL |     c2(); c1();
    |           -- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0524`.
diff --git a/tests/ui/borrowck/borrowck-closures-unique-imm.stderr b/tests/ui/borrowck/borrowck-closures-unique-imm.stderr
index b8bbb31a355..669dd614f52 100644
--- a/tests/ui/borrowck/borrowck-closures-unique-imm.stderr
+++ b/tests/ui/borrowck/borrowck-closures-unique-imm.stderr
@@ -8,6 +8,6 @@ LL |         &mut this.x;
 LL |         p.use_ref();
    |         - immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-closures-use-after-free.stderr b/tests/ui/borrowck/borrowck-closures-use-after-free.stderr
index 30900a3b6d9..bc840577e9b 100644
--- a/tests/ui/borrowck/borrowck-closures-use-after-free.stderr
+++ b/tests/ui/borrowck/borrowck-closures-use-after-free.stderr
@@ -11,6 +11,6 @@ LL |   test(&*ptr);
    |   |
    |   mutable borrow later used by call
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-consume-unsize-vec.stderr b/tests/ui/borrowck/borrowck-consume-unsize-vec.stderr
index d2e9497d079..abd7f19fc95 100644
--- a/tests/ui/borrowck/borrowck-consume-unsize-vec.stderr
+++ b/tests/ui/borrowck/borrowck-consume-unsize-vec.stderr
@@ -20,6 +20,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     consume(b.clone());
    |              ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-consume-upcast-box.stderr b/tests/ui/borrowck/borrowck-consume-upcast-box.stderr
index ed7e883ca63..4c3861cfe7a 100644
--- a/tests/ui/borrowck/borrowck-consume-upcast-box.stderr
+++ b/tests/ui/borrowck/borrowck-consume-upcast-box.stderr
@@ -16,6 +16,6 @@ LL | fn consume(_: Box<dyn Foo>) {
    |    |
    |    in this function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-escaping-closure-error-1.stderr b/tests/ui/borrowck/borrowck-escaping-closure-error-1.stderr
index acf6b37b773..6dcd451736d 100644
--- a/tests/ui/borrowck/borrowck-escaping-closure-error-1.stderr
+++ b/tests/ui/borrowck/borrowck-escaping-closure-error-1.stderr
@@ -16,6 +16,6 @@ help: to force the closure to take ownership of `books` (and any other reference
 LL |     spawn(move || books.push(4));
    |           ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/borrowck/borrowck-escaping-closure-error-2.stderr b/tests/ui/borrowck/borrowck-escaping-closure-error-2.stderr
index 814042539a2..7a1c1510b6a 100644
--- a/tests/ui/borrowck/borrowck-escaping-closure-error-2.stderr
+++ b/tests/ui/borrowck/borrowck-escaping-closure-error-2.stderr
@@ -16,6 +16,6 @@ help: to force the closure to take ownership of `books` (and any other reference
 LL |     Box::new(move || books.push(4))
    |              ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/borrowck/borrowck-fn-in-const-a.stderr b/tests/ui/borrowck/borrowck-fn-in-const-a.stderr
index e7491afdad1..e05696864fd 100644
--- a/tests/ui/borrowck/borrowck-fn-in-const-a.stderr
+++ b/tests/ui/borrowck/borrowck-fn-in-const-a.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of `*x` which is behind a shared reference
 LL |         return *x
    |                ^^ move occurs because `*x` has type `String`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-fn-in-const-c.stderr b/tests/ui/borrowck/borrowck-fn-in-const-c.stderr
index d48866dce04..ee1bb2a4881 100644
--- a/tests/ui/borrowck/borrowck-fn-in-const-c.stderr
+++ b/tests/ui/borrowck/borrowck-fn-in-const-c.stderr
@@ -6,6 +6,6 @@ LL |         return &local.inner;
 LL |     }
    |     - here, drop of `local` needs exclusive access to `local.inner`, because the type `DropString` implements the `Drop` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0713`.
diff --git a/tests/ui/borrowck/borrowck-for-loop-uninitialized-binding.stderr b/tests/ui/borrowck/borrowck-for-loop-uninitialized-binding.stderr
index fc1a44c3ca0..79519e885d0 100644
--- a/tests/ui/borrowck/borrowck-for-loop-uninitialized-binding.stderr
+++ b/tests/ui/borrowck/borrowck-for-loop-uninitialized-binding.stderr
@@ -8,6 +8,6 @@ LL |     for _ in 0..0 { x = 10; }
 LL |     return x;
    |            ^ `x` used here but it is possibly-uninitialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-if-no-else.stderr b/tests/ui/borrowck/borrowck-if-no-else.stderr
index 9eafc2c2a86..f1fad2d36dc 100644
--- a/tests/ui/borrowck/borrowck-if-no-else.stderr
+++ b/tests/ui/borrowck/borrowck-if-no-else.stderr
@@ -9,6 +9,6 @@ LL |     let x: isize; if 1 > 2 { x = 10; }
 LL |     foo(x);
    |         ^ `x` used here but it is possibly-uninitialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-if-with-else.stderr b/tests/ui/borrowck/borrowck-if-with-else.stderr
index 3f0fe291ca2..c246e41487f 100644
--- a/tests/ui/borrowck/borrowck-if-with-else.stderr
+++ b/tests/ui/borrowck/borrowck-if-with-else.stderr
@@ -9,6 +9,6 @@ LL |     if 1 > 2 {
 LL |     foo(x);
    |         ^ `x` used here but it is possibly-uninitialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.stderr b/tests/ui/borrowck/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.stderr
index 1a20ec85fc0..3f052f8fe3b 100644
--- a/tests/ui/borrowck/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.stderr
+++ b/tests/ui/borrowck/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.stderr
@@ -10,6 +10,6 @@ LL |         _a = 4;
 LL |     drop(b);
    |          - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/borrowck-in-static.stderr b/tests/ui/borrowck/borrowck-in-static.stderr
index 2033e4a5730..8171e6950ac 100644
--- a/tests/ui/borrowck/borrowck-in-static.stderr
+++ b/tests/ui/borrowck/borrowck-in-static.stderr
@@ -8,6 +8,6 @@ LL |     Box::new(|| x)
    |              |
    |              captured by this `Fn` closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-init-in-called-fn-expr.stderr b/tests/ui/borrowck/borrowck-init-in-called-fn-expr.stderr
index 1a22b5f0975..a27b6956b30 100644
--- a/tests/ui/borrowck/borrowck-init-in-called-fn-expr.stderr
+++ b/tests/ui/borrowck/borrowck-init-in-called-fn-expr.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |         let i: isize = 0;
    |                      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-init-in-fn-expr.stderr b/tests/ui/borrowck/borrowck-init-in-fn-expr.stderr
index f1b9b9aa709..16f4c40f529 100644
--- a/tests/ui/borrowck/borrowck-init-in-fn-expr.stderr
+++ b/tests/ui/borrowck/borrowck-init-in-fn-expr.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |         let i: isize = 0;
    |                      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-init-in-fru.stderr b/tests/ui/borrowck/borrowck-init-in-fru.stderr
index 39b28811a0c..f27993e10b4 100644
--- a/tests/ui/borrowck/borrowck-init-in-fru.stderr
+++ b/tests/ui/borrowck/borrowck-init-in-fru.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let mut origin: Point = todo!();
    |                           +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-init-op-equal.stderr b/tests/ui/borrowck/borrowck-init-op-equal.stderr
index ef0fa6df4fb..241d24341cb 100644
--- a/tests/ui/borrowck/borrowck-init-op-equal.stderr
+++ b/tests/ui/borrowck/borrowck-init-op-equal.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let v: isize = 0;
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-init-plus-equal.stderr b/tests/ui/borrowck/borrowck-init-plus-equal.stderr
index cec05331836..65de6e8bf5d 100644
--- a/tests/ui/borrowck/borrowck-init-plus-equal.stderr
+++ b/tests/ui/borrowck/borrowck-init-plus-equal.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let mut v: isize = 0;
    |                      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-issue-2657-1.stderr b/tests/ui/borrowck/borrowck-issue-2657-1.stderr
index 4ea4eb8f007..194403fc17e 100644
--- a/tests/ui/borrowck/borrowck-issue-2657-1.stderr
+++ b/tests/ui/borrowck/borrowck-issue-2657-1.stderr
@@ -8,6 +8,6 @@ LL |         let _a = x;
 LL |         _y.use_ref();
    |         -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-issue-2657-2.stderr b/tests/ui/borrowck/borrowck-issue-2657-2.stderr
index 850bb9ae393..6fab19000fc 100644
--- a/tests/ui/borrowck/borrowck-issue-2657-2.stderr
+++ b/tests/ui/borrowck/borrowck-issue-2657-2.stderr
@@ -10,6 +10,6 @@ LL -         let _b = *y;
 LL +         let _b = y;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-lend-flow-if.stderr b/tests/ui/borrowck/borrowck-lend-flow-if.stderr
index 68a82bdb57c..abcd14f9a56 100644
--- a/tests/ui/borrowck/borrowck-lend-flow-if.stderr
+++ b/tests/ui/borrowck/borrowck-lend-flow-if.stderr
@@ -9,6 +9,6 @@ LL |     borrow_mut(&mut *v);
 LL |     _w.use_ref();
    |     -- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-lend-flow-match.stderr b/tests/ui/borrowck/borrowck-lend-flow-match.stderr
index 6cdce7bee88..3e9124bdc27 100644
--- a/tests/ui/borrowck/borrowck-lend-flow-match.stderr
+++ b/tests/ui/borrowck/borrowck-lend-flow-match.stderr
@@ -8,6 +8,6 @@ LL |             x = Some(1);
 LL |             drop(r);
    |                  - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/borrowck-lend-flow.stderr b/tests/ui/borrowck/borrowck-lend-flow.stderr
index 07b11b3e728..0c60b094834 100644
--- a/tests/ui/borrowck/borrowck-lend-flow.stderr
+++ b/tests/ui/borrowck/borrowck-lend-flow.stderr
@@ -8,6 +8,6 @@ LL |     borrow_mut(&mut *v);
 LL |     _w.use_ref();
    |     -- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-loan-blocks-move.stderr b/tests/ui/borrowck/borrowck-loan-blocks-move.stderr
index de8da490c2e..d1fbc5b47db 100644
--- a/tests/ui/borrowck/borrowck-loan-blocks-move.stderr
+++ b/tests/ui/borrowck/borrowck-loan-blocks-move.stderr
@@ -10,6 +10,6 @@ LL |     take(v);
 LL |     w.use_ref();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-loan-blocks-mut-uniq.stderr b/tests/ui/borrowck/borrowck-loan-blocks-mut-uniq.stderr
index fa5308c2903..3285c7f0ca1 100644
--- a/tests/ui/borrowck/borrowck-loan-blocks-mut-uniq.stderr
+++ b/tests/ui/borrowck/borrowck-loan-blocks-mut-uniq.stderr
@@ -10,6 +10,6 @@ LL |            |w| {
 LL |             v = Box::new(4);
    |             - second borrow occurs due to use of `v` in closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-loan-in-overloaded-op.stderr b/tests/ui/borrowck/borrowck-loan-in-overloaded-op.stderr
index 93622a0c5f6..5f1e3994af2 100644
--- a/tests/ui/borrowck/borrowck-loan-in-overloaded-op.stderr
+++ b/tests/ui/borrowck/borrowck-loan-in-overloaded-op.stderr
@@ -13,6 +13,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     let _y = {x.clone()} + x.clone(); // the `{x}` forces a move to occur
    |                ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-loan-of-static-data-issue-27616.stderr b/tests/ui/borrowck/borrowck-loan-of-static-data-issue-27616.stderr
index 311369a260d..838568fd32c 100644
--- a/tests/ui/borrowck/borrowck-loan-of-static-data-issue-27616.stderr
+++ b/tests/ui/borrowck/borrowck-loan-of-static-data-issue-27616.stderr
@@ -9,6 +9,6 @@ LL |     let alias: &'static mut String = s;
 LL |     *s = String::new();
    |     ^^ `*s` is assigned to here but it was already borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/borrowck-loan-vec-content.stderr b/tests/ui/borrowck/borrowck-loan-vec-content.stderr
index 6691a2396a1..eb11dfa38b8 100644
--- a/tests/ui/borrowck/borrowck-loan-vec-content.stderr
+++ b/tests/ui/borrowck/borrowck-loan-vec-content.stderr
@@ -10,6 +10,6 @@ LL |         || {
 LL |             v[1] = 4;
    |             - second borrow occurs due to use of `v` in closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-local-borrow-outlives-fn.stderr b/tests/ui/borrowck/borrowck-local-borrow-outlives-fn.stderr
index 9d19de211a5..9c26bc353ab 100644
--- a/tests/ui/borrowck/borrowck-local-borrow-outlives-fn.stderr
+++ b/tests/ui/borrowck/borrowck-local-borrow-outlives-fn.stderr
@@ -4,6 +4,6 @@ error[E0515]: cannot return reference to function parameter `x`
 LL |     &x
    |     ^^ returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/borrowck/borrowck-local-borrow-with-panic-outlives-fn.stderr b/tests/ui/borrowck/borrowck-local-borrow-with-panic-outlives-fn.stderr
index 0fdb1dabbc5..bac9c2790c5 100644
--- a/tests/ui/borrowck/borrowck-local-borrow-with-panic-outlives-fn.stderr
+++ b/tests/ui/borrowck/borrowck-local-borrow-with-panic-outlives-fn.stderr
@@ -12,6 +12,6 @@ LL |     *x = Some(&mut z.1);
 LL | }
    | - `z.1` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/borrowck/borrowck-move-by-capture.stderr b/tests/ui/borrowck/borrowck-move-by-capture.stderr
index 6eaa1fa3169..01647011207 100644
--- a/tests/ui/borrowck/borrowck-move-by-capture.stderr
+++ b/tests/ui/borrowck/borrowck-move-by-capture.stderr
@@ -12,6 +12,6 @@ LL |         let _h = to_fn_once(move || -> isize { *bar });
    |                             |                  move occurs because `bar` has type `Box<isize>`, which does not implement the `Copy` trait
    |                             `bar` is moved here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr b/tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr
index 4f0202f3832..a41c4af98e7 100644
--- a/tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr
+++ b/tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr
@@ -11,6 +11,6 @@ LL |     let z = *a;
 LL |     b.use_ref();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-move-from-unsafe-ptr.stderr b/tests/ui/borrowck/borrowck-move-from-unsafe-ptr.stderr
index 43fc102bd62..7213f85ad98 100644
--- a/tests/ui/borrowck/borrowck-move-from-unsafe-ptr.stderr
+++ b/tests/ui/borrowck/borrowck-move-from-unsafe-ptr.stderr
@@ -10,6 +10,6 @@ LL -     let y = *x;
 LL +     let y = x;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-move-moved-value-into-closure.stderr b/tests/ui/borrowck/borrowck-move-moved-value-into-closure.stderr
index 9509ebb7cde..6a77d86f250 100644
--- a/tests/ui/borrowck/borrowck-move-moved-value-into-closure.stderr
+++ b/tests/ui/borrowck/borrowck-move-moved-value-into-closure.stderr
@@ -13,6 +13,6 @@ LL |     call_f(move|| { *t + 1 });
    |            |
    |            value used here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr b/tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr
index e1e3c7f8aaa..88eb6c8ceee 100644
--- a/tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr
+++ b/tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr
@@ -11,6 +11,6 @@ LL |     *t1 = 22;
 LL |     p.use_ref();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-move-out-of-overloaded-auto-deref.stderr b/tests/ui/borrowck/borrowck-move-out-of-overloaded-auto-deref.stderr
index 934dd8df1d2..02794a12fad 100644
--- a/tests/ui/borrowck/borrowck-move-out-of-overloaded-auto-deref.stderr
+++ b/tests/ui/borrowck/borrowck-move-out-of-overloaded-auto-deref.stderr
@@ -13,6 +13,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |     let _x = Rc::new(vec![1, 2]).clone().into_iter();
    |                                 ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-move-out-of-overloaded-deref.stderr b/tests/ui/borrowck/borrowck-move-out-of-overloaded-deref.stderr
index 599fa1e88df..dce1f4d0775 100644
--- a/tests/ui/borrowck/borrowck-move-out-of-overloaded-deref.stderr
+++ b/tests/ui/borrowck/borrowck-move-out-of-overloaded-deref.stderr
@@ -10,6 +10,6 @@ LL -     let _x = *Rc::new("hi".to_string());
 LL +     let _x = Rc::new("hi".to_string());
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-move-out-of-static-item.stderr b/tests/ui/borrowck/borrowck-move-out-of-static-item.stderr
index edf8c954f81..07dcaf875e7 100644
--- a/tests/ui/borrowck/borrowck-move-out-of-static-item.stderr
+++ b/tests/ui/borrowck/borrowck-move-out-of-static-item.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of static item `BAR`
 LL |     test(BAR);
    |          ^^^ move occurs because `BAR` has type `Foo`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-move-out-of-vec-tail.stderr b/tests/ui/borrowck/borrowck-move-out-of-vec-tail.stderr
index 9ff20a1f46a..4fa23f16bfd 100644
--- a/tests/ui/borrowck/borrowck-move-out-of-vec-tail.stderr
+++ b/tests/ui/borrowck/borrowck-move-out-of-vec-tail.stderr
@@ -16,6 +16,6 @@ LL -                 &[Foo { string: a },
 LL +                 [Foo { string: a },
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/borrowck/borrowck-move-subcomponent.stderr b/tests/ui/borrowck/borrowck-move-subcomponent.stderr
index 341146bd18f..8408d99156a 100644
--- a/tests/ui/borrowck/borrowck-move-subcomponent.stderr
+++ b/tests/ui/borrowck/borrowck-move-subcomponent.stderr
@@ -10,6 +10,6 @@ LL |   let S { x: ax } = a;
 LL |   f(pb);
    |     -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-mut-addr-of-imm-var.stderr b/tests/ui/borrowck/borrowck-mut-addr-of-imm-var.stderr
index 20528e3f0ee..84f35dc2249 100644
--- a/tests/ui/borrowck/borrowck-mut-addr-of-imm-var.stderr
+++ b/tests/ui/borrowck/borrowck-mut-addr-of-imm-var.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut x: isize = 3;
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/borrowck-mut-slice-of-imm-vec.stderr b/tests/ui/borrowck/borrowck-mut-slice-of-imm-vec.stderr
index 8ab472e64c7..823f470ce8e 100644
--- a/tests/ui/borrowck/borrowck-mut-slice-of-imm-vec.stderr
+++ b/tests/ui/borrowck/borrowck-mut-slice-of-imm-vec.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut v = vec![1, 2, 3];
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/borrowck-no-cycle-in-exchange-heap.stderr b/tests/ui/borrowck/borrowck-no-cycle-in-exchange-heap.stderr
index 3462b7610d3..bde43a90850 100644
--- a/tests/ui/borrowck/borrowck-no-cycle-in-exchange-heap.stderr
+++ b/tests/ui/borrowck/borrowck-no-cycle-in-exchange-heap.stderr
@@ -8,6 +8,6 @@ LL |         y.a = x;
    |         |
    |         borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-or-init.stderr b/tests/ui/borrowck/borrowck-or-init.stderr
index 16d66bf40d1..7b43f2aee30 100644
--- a/tests/ui/borrowck/borrowck-or-init.stderr
+++ b/tests/ui/borrowck/borrowck-or-init.stderr
@@ -11,6 +11,6 @@ LL |     println!("{}", i);
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-overloaded-index-and-overloaded-deref.stderr b/tests/ui/borrowck/borrowck-overloaded-index-and-overloaded-deref.stderr
index 7f42becd21c..7b2cac98796 100644
--- a/tests/ui/borrowck/borrowck-overloaded-index-and-overloaded-deref.stderr
+++ b/tests/ui/borrowck/borrowck-overloaded-index-and-overloaded-deref.stderr
@@ -9,6 +9,6 @@ LL |
 LL |     read(*i);
    |          -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/borrowck-overloaded-index-move-from-vec.stderr b/tests/ui/borrowck/borrowck-overloaded-index-move-from-vec.stderr
index f5f4817e9bf..b4106702cd1 100644
--- a/tests/ui/borrowck/borrowck-overloaded-index-move-from-vec.stderr
+++ b/tests/ui/borrowck/borrowck-overloaded-index-move-from-vec.stderr
@@ -9,6 +9,6 @@ help: consider borrowing here
 LL |     let bad = &v[0];
    |               +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/borrowck-partial-reinit-2.stderr b/tests/ui/borrowck/borrowck-partial-reinit-2.stderr
index 36a871fbb12..e25ca082b7b 100644
--- a/tests/ui/borrowck/borrowck-partial-reinit-2.stderr
+++ b/tests/ui/borrowck/borrowck-partial-reinit-2.stderr
@@ -8,6 +8,6 @@ LL |     let mut u = Test { a: 2, b: Some(Box::new(t))};
 LL |     t.b = Some(Box::new(u));
    |     ^^^ value assigned here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-partial-reinit-3.stderr b/tests/ui/borrowck/borrowck-partial-reinit-3.stderr
index 05f5411eed6..29173795238 100644
--- a/tests/ui/borrowck/borrowck-partial-reinit-3.stderr
+++ b/tests/ui/borrowck/borrowck-partial-reinit-3.stderr
@@ -8,6 +8,6 @@ LL |     x.0.f = 3;
    |
    = note: move occurs because `x.0` has type `Test`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-partial-reinit-4.stderr b/tests/ui/borrowck/borrowck-partial-reinit-4.stderr
index d12a482cb69..4833e689c19 100644
--- a/tests/ui/borrowck/borrowck-partial-reinit-4.stderr
+++ b/tests/ui/borrowck/borrowck-partial-reinit-4.stderr
@@ -8,6 +8,6 @@ LL |     (x.0).0 = Some(Test);
    |
    = help: partial initialization isn't supported, fully initialize the binding with a default value and mutate it, or use `std::mem::MaybeUninit`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-pat-reassign-binding.stderr b/tests/ui/borrowck/borrowck-pat-reassign-binding.stderr
index b86a8693881..387c681fddf 100644
--- a/tests/ui/borrowck/borrowck-pat-reassign-binding.stderr
+++ b/tests/ui/borrowck/borrowck-pat-reassign-binding.stderr
@@ -9,6 +9,6 @@ LL |           x = Some(*i+1);
 LL |           drop(i);
    |                - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/borrowck-reborrow-from-shorter-lived-andmut.stderr b/tests/ui/borrowck/borrowck-reborrow-from-shorter-lived-andmut.stderr
index f28c42ce2d5..65748d844fa 100644
--- a/tests/ui/borrowck/borrowck-reborrow-from-shorter-lived-andmut.stderr
+++ b/tests/ui/borrowck/borrowck-reborrow-from-shorter-lived-andmut.stderr
@@ -10,5 +10,5 @@ LL |     S { pointer: &mut *p.pointer }
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/borrowck-ref-mut-of-imm.stderr b/tests/ui/borrowck/borrowck-ref-mut-of-imm.stderr
index 5cfd81bd004..5f319112b86 100644
--- a/tests/ui/borrowck/borrowck-ref-mut-of-imm.stderr
+++ b/tests/ui/borrowck/borrowck-ref-mut-of-imm.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL | fn destructure(mut x: Option<isize>) -> isize {
    |                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/borrowck-reinit.stderr b/tests/ui/borrowck/borrowck-reinit.stderr
index f785900d53f..16047efa32b 100644
--- a/tests/ui/borrowck/borrowck-reinit.stderr
+++ b/tests/ui/borrowck/borrowck-reinit.stderr
@@ -14,6 +14,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     drop(x.clone());
    |           ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-return-variable-on-stack-via-clone.stderr b/tests/ui/borrowck/borrowck-return-variable-on-stack-via-clone.stderr
index d54449ac4ad..eade7d1ea95 100644
--- a/tests/ui/borrowck/borrowck-return-variable-on-stack-via-clone.stderr
+++ b/tests/ui/borrowck/borrowck-return-variable-on-stack-via-clone.stderr
@@ -7,6 +7,6 @@ LL |     (&x).clone()
    |     returns a value referencing data owned by the current function
    |     `x` is borrowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/borrowck/borrowck-return.stderr b/tests/ui/borrowck/borrowck-return.stderr
index 9799357c9ca..a1bc3008ea8 100644
--- a/tests/ui/borrowck/borrowck-return.stderr
+++ b/tests/ui/borrowck/borrowck-return.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let x: isize = 0;
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-storage-dead.stderr b/tests/ui/borrowck/borrowck-storage-dead.stderr
index 3a413153acd..a08e2a7b535 100644
--- a/tests/ui/borrowck/borrowck-storage-dead.stderr
+++ b/tests/ui/borrowck/borrowck-storage-dead.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |         let x: i32 = 0;
    |                    +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-swap-mut-base-ptr.stderr b/tests/ui/borrowck/borrowck-swap-mut-base-ptr.stderr
index 1c55953c91f..225a983bab4 100644
--- a/tests/ui/borrowck/borrowck-swap-mut-base-ptr.stderr
+++ b/tests/ui/borrowck/borrowck-swap-mut-base-ptr.stderr
@@ -9,6 +9,6 @@ LL |     *t1 = 22;
 LL |     p.use_ref();
    |     - immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/borrowck-thread-local-static-borrow-outlives-fn.stderr b/tests/ui/borrowck/borrowck-thread-local-static-borrow-outlives-fn.stderr
index 2f397f6b585..11ee8f7bb91 100644
--- a/tests/ui/borrowck/borrowck-thread-local-static-borrow-outlives-fn.stderr
+++ b/tests/ui/borrowck/borrowck-thread-local-static-borrow-outlives-fn.stderr
@@ -6,6 +6,6 @@ LL |      assert_static(&FOO);
 LL | }
    |  - end of enclosing function is here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0712`.
diff --git a/tests/ui/borrowck/borrowck-unary-move.stderr b/tests/ui/borrowck/borrowck-unary-move.stderr
index f3b962059f5..e6c3869f67a 100644
--- a/tests/ui/borrowck/borrowck-unary-move.stderr
+++ b/tests/ui/borrowck/borrowck-unary-move.stderr
@@ -10,6 +10,6 @@ LL |     free(x);
 LL |     *y
    |     -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/borrowck-uninit-after-item.stderr b/tests/ui/borrowck/borrowck-uninit-after-item.stderr
index 071598b42ee..06bb419aa3b 100644
--- a/tests/ui/borrowck/borrowck-uninit-after-item.stderr
+++ b/tests/ui/borrowck/borrowck-uninit-after-item.stderr
@@ -12,6 +12,6 @@ help: consider assigning a value
 LL |     let bar = 0;
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-uninit.stderr b/tests/ui/borrowck/borrowck-uninit.stderr
index eeafc4ce191..213b541b8a9 100644
--- a/tests/ui/borrowck/borrowck-uninit.stderr
+++ b/tests/ui/borrowck/borrowck-uninit.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let x: isize = 0;
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-union-borrow-nested.stderr b/tests/ui/borrowck/borrowck-union-borrow-nested.stderr
index f2e549cd88c..68a950dfdaa 100644
--- a/tests/ui/borrowck/borrowck-union-borrow-nested.stderr
+++ b/tests/ui/borrowck/borrowck-union-borrow-nested.stderr
@@ -8,6 +8,6 @@ LL |             let b = u.c;
 LL |             ra.use_mut();
    |             -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/borrowck/borrowck-union-move-assign.stderr b/tests/ui/borrowck/borrowck-union-move-assign.stderr
index af6f6fac408..8c0239a3ae9 100644
--- a/tests/ui/borrowck/borrowck-union-move-assign.stderr
+++ b/tests/ui/borrowck/borrowck-union-move-assign.stderr
@@ -8,6 +8,6 @@ LL |             let a = u.a;
 LL |             let a = u.a;
    |                     ^^^ value used here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/borrowck-use-uninitialized-in-cast-trait.stderr b/tests/ui/borrowck/borrowck-use-uninitialized-in-cast-trait.stderr
index 55f3ff553c1..dcbaa75333e 100644
--- a/tests/ui/borrowck/borrowck-use-uninitialized-in-cast-trait.stderr
+++ b/tests/ui/borrowck/borrowck-use-uninitialized-in-cast-trait.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let x: &i32 = todo!();
    |                 +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-use-uninitialized-in-cast.stderr b/tests/ui/borrowck/borrowck-use-uninitialized-in-cast.stderr
index ea3d0d3ef51..7ccf6a4c3fc 100644
--- a/tests/ui/borrowck/borrowck-use-uninitialized-in-cast.stderr
+++ b/tests/ui/borrowck/borrowck-use-uninitialized-in-cast.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let x: &i32 = todo!();
    |                 +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-vec-pattern-loan-from-mut.stderr b/tests/ui/borrowck/borrowck-vec-pattern-loan-from-mut.stderr
index 5141fcc1bb2..d5964d28b08 100644
--- a/tests/ui/borrowck/borrowck-vec-pattern-loan-from-mut.stderr
+++ b/tests/ui/borrowck/borrowck-vec-pattern-loan-from-mut.stderr
@@ -9,6 +9,6 @@ LL |             v.push(tail[0] + tail[1]);
    |             |
    |             second mutable borrow occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/borrowck-vec-pattern-move-tail.stderr b/tests/ui/borrowck/borrowck-vec-pattern-move-tail.stderr
index 494d8c351a1..03a7efacb33 100644
--- a/tests/ui/borrowck/borrowck-vec-pattern-move-tail.stderr
+++ b/tests/ui/borrowck/borrowck-vec-pattern-move-tail.stderr
@@ -9,6 +9,6 @@ LL |     a[2] = 0;
 LL |     println!("t[0]: {}", t[0]);
    |                          ---- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/borrowck-vec-pattern-tail-element-loan.stderr b/tests/ui/borrowck/borrowck-vec-pattern-tail-element-loan.stderr
index 7e21c55f21b..2187437a1cd 100644
--- a/tests/ui/borrowck/borrowck-vec-pattern-tail-element-loan.stderr
+++ b/tests/ui/borrowck/borrowck-vec-pattern-tail-element-loan.stderr
@@ -7,6 +7,6 @@ LL |     let vec: &[isize] = &vec;
 LL |     tail
    |     ^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/borrowck/borrowck-while-break.stderr b/tests/ui/borrowck/borrowck-while-break.stderr
index 13143d436df..e91af728b64 100644
--- a/tests/ui/borrowck/borrowck-while-break.stderr
+++ b/tests/ui/borrowck/borrowck-while-break.stderr
@@ -11,6 +11,6 @@ LL |     println!("{}", v);
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-while-cond.stderr b/tests/ui/borrowck/borrowck-while-cond.stderr
index 5d019498956..2d92b45e02a 100644
--- a/tests/ui/borrowck/borrowck-while-cond.stderr
+++ b/tests/ui/borrowck/borrowck-while-cond.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let x: bool = false;
    |                 +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/borrowck-while.stderr b/tests/ui/borrowck/borrowck-while.stderr
index c45235990c3..d560b9c02fb 100644
--- a/tests/ui/borrowck/borrowck-while.stderr
+++ b/tests/ui/borrowck/borrowck-while.stderr
@@ -8,6 +8,6 @@ LL |     while 1 == 1 { x = 10; }
 LL |     return x;
    |            ^ `x` used here but it is possibly-uninitialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/clone-span-on-try-operator.stderr b/tests/ui/borrowck/clone-span-on-try-operator.stderr
index 85785e67072..5a55088d67a 100644
--- a/tests/ui/borrowck/clone-span-on-try-operator.stderr
+++ b/tests/ui/borrowck/clone-span-on-try-operator.stderr
@@ -16,6 +16,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |     (*foo).clone().foo();
    |           ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/copy-suggestion-region-vid.stderr b/tests/ui/borrowck/copy-suggestion-region-vid.stderr
index b344aa66405..3a801a22ea2 100644
--- a/tests/ui/borrowck/copy-suggestion-region-vid.stderr
+++ b/tests/ui/borrowck/copy-suggestion-region-vid.stderr
@@ -14,6 +14,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         HelperStruct { helpers: helpers.clone(), is_empty: helpers[0].is_empty() }
    |                               +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/do-not-suggest-adding-move-when-closure-is-already-marked-as-move.stderr b/tests/ui/borrowck/do-not-suggest-adding-move-when-closure-is-already-marked-as-move.stderr
index 78ca090feb7..879ff8be0e8 100644
--- a/tests/ui/borrowck/do-not-suggest-adding-move-when-closure-is-already-marked-as-move.stderr
+++ b/tests/ui/borrowck/do-not-suggest-adding-move-when-closure-is-already-marked-as-move.stderr
@@ -14,5 +14,5 @@ LL |         move || { iter.next() }
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/drop-in-loop.stderr b/tests/ui/borrowck/drop-in-loop.stderr
index d5734e7ec97..98dae19a7d4 100644
--- a/tests/ui/borrowck/drop-in-loop.stderr
+++ b/tests/ui/borrowck/drop-in-loop.stderr
@@ -9,6 +9,6 @@ LL |         base = false;
 LL |         wrapper = WrapperWithDrop(&mut base);
    |         ------- borrow might be used here, when `wrapper` is dropped and runs the `Drop` code for type `WrapperWithDrop`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/immutable-arg.stderr b/tests/ui/borrowck/immutable-arg.stderr
index bddb0633a0b..84a480f6410 100644
--- a/tests/ui/borrowck/immutable-arg.stderr
+++ b/tests/ui/borrowck/immutable-arg.stderr
@@ -6,6 +6,6 @@ LL | fn foo(_x: u32) {
 LL |     _x = 4;
    |     ^^^^^^ cannot assign to immutable argument
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/borrowck/index-mut-help-with-impl.stderr b/tests/ui/borrowck/index-mut-help-with-impl.stderr
index 89391f4099a..a97f2bdd4c9 100644
--- a/tests/ui/borrowck/index-mut-help-with-impl.stderr
+++ b/tests/ui/borrowck/index-mut-help-with-impl.stderr
@@ -4,6 +4,6 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     Index::index(&v, 1..2).make_ascii_uppercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-101119.stderr b/tests/ui/borrowck/issue-101119.stderr
index a22afdc6764..1f32ece3d3d 100644
--- a/tests/ui/borrowck/issue-101119.stderr
+++ b/tests/ui/borrowck/issue-101119.stderr
@@ -10,6 +10,6 @@ LL |
 LL |             fill_segment(state);
    |                          ----- use occurs due to use in closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/issue-103250.stderr b/tests/ui/borrowck/issue-103250.stderr
index 4a237835222..b7ece5d971d 100644
--- a/tests/ui/borrowck/issue-103250.stderr
+++ b/tests/ui/borrowck/issue-103250.stderr
@@ -12,6 +12,6 @@ help: consider assigning a value
 LL |         let mut last_error: Box<dyn std::error::Error> = todo!();
    |                                                        +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/issue-11493.stderr b/tests/ui/borrowck/issue-11493.stderr
index 2720b09b0fc..211d4cb3e4b 100644
--- a/tests/ui/borrowck/issue-11493.stderr
+++ b/tests/ui/borrowck/issue-11493.stderr
@@ -14,6 +14,6 @@ LL ~     let binding = id(5);
 LL ~     let y = x.as_ref().unwrap_or(&binding);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/issue-115259-suggest-iter-mut.stderr b/tests/ui/borrowck/issue-115259-suggest-iter-mut.stderr
index 7e0fc2cf298..40ab2e61d6a 100644
--- a/tests/ui/borrowck/issue-115259-suggest-iter-mut.stderr
+++ b/tests/ui/borrowck/issue-115259-suggest-iter-mut.stderr
@@ -11,6 +11,6 @@ help: you may want to use `iter_mut` here
 LL |         self.layers.iter_mut().fold(0, |result, mut layer| result + layer.process())
    |                     ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-17545.stderr b/tests/ui/borrowck/issue-17545.stderr
index 3ae7e64d202..45e977e3947 100644
--- a/tests/ui/borrowck/issue-17545.stderr
+++ b/tests/ui/borrowck/issue-17545.stderr
@@ -11,6 +11,6 @@ LL | |     ));
    | |______|
    |        argument requires that borrow lasts for `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/issue-17718-static-move.stderr b/tests/ui/borrowck/issue-17718-static-move.stderr
index 65aea5b1834..5ca0a7fb885 100644
--- a/tests/ui/borrowck/issue-17718-static-move.stderr
+++ b/tests/ui/borrowck/issue-17718-static-move.stderr
@@ -9,6 +9,6 @@ help: consider borrowing here
 LL |     let _a = &FOO;
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/issue-25793.stderr b/tests/ui/borrowck/issue-25793.stderr
index 27dab53e48f..e2efc405fab 100644
--- a/tests/ui/borrowck/issue-25793.stderr
+++ b/tests/ui/borrowck/issue-25793.stderr
@@ -13,6 +13,6 @@ LL |         r.get_size(width!(self))
    |
    = note: this error originates in the macro `width` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/borrowck/issue-33819.stderr b/tests/ui/borrowck/issue-33819.stderr
index f77fdbf2b6b..41c9d6aac76 100644
--- a/tests/ui/borrowck/issue-33819.stderr
+++ b/tests/ui/borrowck/issue-33819.stderr
@@ -7,6 +7,6 @@ LL |         Some(ref v) => { let a = &mut v; },
    |                                  cannot borrow as mutable
    |                                  help: try removing `&mut` here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-36082.stderr b/tests/ui/borrowck/issue-36082.stderr
index a6357f8182f..47c78d6863b 100644
--- a/tests/ui/borrowck/issue-36082.stderr
+++ b/tests/ui/borrowck/issue-36082.stderr
@@ -15,6 +15,6 @@ LL ~     let binding = x.borrow();
 LL ~     let val: &_ = binding.0;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/issue-41962.stderr b/tests/ui/borrowck/issue-41962.stderr
index 716cc9d0c8b..8585376b92d 100644
--- a/tests/ui/borrowck/issue-41962.stderr
+++ b/tests/ui/borrowck/issue-41962.stderr
@@ -10,6 +10,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |         if let Some(ref thing) = maybe {
    |                     +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/issue-42344.stderr b/tests/ui/borrowck/issue-42344.stderr
index 5cffa1b5121..bf82d462b51 100644
--- a/tests/ui/borrowck/issue-42344.stderr
+++ b/tests/ui/borrowck/issue-42344.stderr
@@ -4,6 +4,6 @@ error[E0596]: cannot borrow `*TAB[_]` as mutable, as `TAB` is an immutable stati
 LL |     TAB[0].iter_mut();
    |     ^^^^^^ cannot borrow as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-45983.stderr b/tests/ui/borrowck/issue-45983.stderr
index feb098c5985..19a4a98bb1f 100644
--- a/tests/ui/borrowck/issue-45983.stderr
+++ b/tests/ui/borrowck/issue-45983.stderr
@@ -8,6 +8,6 @@ LL |     give_any(|y| x = Some(y));
    |               |
    |               `y` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/borrowck/issue-46471.stderr b/tests/ui/borrowck/issue-46471.stderr
index 935414c1f3f..17e4b5e8dcf 100644
--- a/tests/ui/borrowck/issue-46471.stderr
+++ b/tests/ui/borrowck/issue-46471.stderr
@@ -4,6 +4,6 @@ error[E0515]: cannot return reference to local variable `x`
 LL |     &x
    |     ^^ returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/borrowck/issue-47215-ice-from-drop-elab.stderr b/tests/ui/borrowck/issue-47215-ice-from-drop-elab.stderr
index 8d4918867f7..d6aeb410ec4 100644
--- a/tests/ui/borrowck/issue-47215-ice-from-drop-elab.stderr
+++ b/tests/ui/borrowck/issue-47215-ice-from-drop-elab.stderr
@@ -9,6 +9,6 @@ help: consider borrowing here
 LL |         let mut x = &X;
    |                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/issue-47646.stderr b/tests/ui/borrowck/issue-47646.stderr
index d82e1f908cb..85adfc03d10 100644
--- a/tests/ui/borrowck/issue-47646.stderr
+++ b/tests/ui/borrowck/issue-47646.stderr
@@ -15,6 +15,6 @@ LL |     };
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/issue-51117.stderr b/tests/ui/borrowck/issue-51117.stderr
index f8a9608ad37..d19fa18dfb6 100644
--- a/tests/ui/borrowck/issue-51117.stderr
+++ b/tests/ui/borrowck/issue-51117.stderr
@@ -8,6 +8,6 @@ LL |             bar.take();
 LL |             drop(baz);
    |                  --- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/issue-51301.stderr b/tests/ui/borrowck/issue-51301.stderr
index 6ec920cb81f..c0b06437093 100644
--- a/tests/ui/borrowck/issue-51301.stderr
+++ b/tests/ui/borrowck/issue-51301.stderr
@@ -12,6 +12,6 @@ help: consider borrowing the pattern binding
 LL |             .find(|(&ref event_type, _)| event == event_type)
    |                      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/issue-51415.stderr b/tests/ui/borrowck/issue-51415.stderr
index 0d486b45592..e51e0b33ebd 100644
--- a/tests/ui/borrowck/issue-51415.stderr
+++ b/tests/ui/borrowck/issue-51415.stderr
@@ -12,6 +12,6 @@ help: consider borrowing the pattern binding
 LL |     let opt = a.iter().enumerate().find(|(_, &ref s)| {
    |                                               +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/issue-52713-bug.stderr b/tests/ui/borrowck/issue-52713-bug.stderr
index 3f7715645e6..ac4936bac4b 100644
--- a/tests/ui/borrowck/issue-52713-bug.stderr
+++ b/tests/ui/borrowck/issue-52713-bug.stderr
@@ -9,6 +9,6 @@ LL |     x += 1;
 LL |     println!("{}", y);
    |                    - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-53432-nested-closure-outlives-borrowed-value.stderr b/tests/ui/borrowck/issue-53432-nested-closure-outlives-borrowed-value.stderr
index 3debfb62c3f..5887752800b 100644
--- a/tests/ui/borrowck/issue-53432-nested-closure-outlives-borrowed-value.stderr
+++ b/tests/ui/borrowck/issue-53432-nested-closure-outlives-borrowed-value.stderr
@@ -15,5 +15,5 @@ help: consider adding 'move' keyword before the nested closure
 LL |         move || f() // The `nested` closure
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/issue-54597-reject-move-out-of-borrow-via-pat.stderr b/tests/ui/borrowck/issue-54597-reject-move-out-of-borrow-via-pat.stderr
index 99c63e4db50..121c2e870e7 100644
--- a/tests/ui/borrowck/issue-54597-reject-move-out-of-borrow-via-pat.stderr
+++ b/tests/ui/borrowck/issue-54597-reject-move-out-of-borrow-via-pat.stderr
@@ -10,6 +10,6 @@ LL -             *array
 LL +             array
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/issue-58776-borrowck-scans-children.stderr b/tests/ui/borrowck/issue-58776-borrowck-scans-children.stderr
index 967451c68be..630d07d652b 100644
--- a/tests/ui/borrowck/issue-58776-borrowck-scans-children.stderr
+++ b/tests/ui/borrowck/issue-58776-borrowck-scans-children.stderr
@@ -12,6 +12,6 @@ LL |     greeting = "DEALLOCATED".to_string();
 LL |     println!("thread result: {:?}", res);
    |                                     --- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-62107-match-arm-scopes.stderr b/tests/ui/borrowck/issue-62107-match-arm-scopes.stderr
index 8fe8fa71064..e19f37538c1 100644
--- a/tests/ui/borrowck/issue-62107-match-arm-scopes.stderr
+++ b/tests/ui/borrowck/issue-62107-match-arm-scopes.stderr
@@ -12,6 +12,6 @@ help: consider assigning a value
 LL |     let e: i32 = 0;
    |                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/borrowck/issue-62387-suggest-iter-mut-2.stderr b/tests/ui/borrowck/issue-62387-suggest-iter-mut-2.stderr
index 19f194100a1..466f19eb0ab 100644
--- a/tests/ui/borrowck/issue-62387-suggest-iter-mut-2.stderr
+++ b/tests/ui/borrowck/issue-62387-suggest-iter-mut-2.stderr
@@ -11,6 +11,6 @@ help: you may want to use `iter_mut` here
 LL |             vec.iter_mut().flat_map(|container| container.things()).cloned().collect::<Vec<PathBuf>>();
    |                 ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-69789-iterator-mut-suggestion.stderr b/tests/ui/borrowck/issue-69789-iterator-mut-suggestion.stderr
index 369a8c61d2c..87b8e059135 100644
--- a/tests/ui/borrowck/issue-69789-iterator-mut-suggestion.stderr
+++ b/tests/ui/borrowck/issue-69789-iterator-mut-suggestion.stderr
@@ -7,6 +7,6 @@ LL |
 LL |         *item = ();
    |         ^^^^^^^^^^ `item` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/borrowck/issue-7573.stderr b/tests/ui/borrowck/issue-7573.stderr
index 9d86286b867..07a67474c83 100644
--- a/tests/ui/borrowck/issue-7573.stderr
+++ b/tests/ui/borrowck/issue-7573.stderr
@@ -10,6 +10,6 @@ LL |
 LL |         lines_to_use.push(installed_id);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `installed_id` escapes the closure body here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/borrowck/issue-81365-1.stderr b/tests/ui/borrowck/issue-81365-1.stderr
index 0d803b0427a..94566ae1951 100644
--- a/tests/ui/borrowck/issue-81365-1.stderr
+++ b/tests/ui/borrowck/issue-81365-1.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = DerefTarget;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-10.stderr b/tests/ui/borrowck/issue-81365-10.stderr
index 2bbde82fafd..7681ee68c0f 100644
--- a/tests/ui/borrowck/issue-81365-10.stderr
+++ b/tests/ui/borrowck/issue-81365-10.stderr
@@ -8,6 +8,6 @@ LL |         self.container_field = true;
 LL |         first;
    |         ----- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-11.stderr b/tests/ui/borrowck/issue-81365-11.stderr
index 5f7e86f11dc..f1f28dcceb0 100644
--- a/tests/ui/borrowck/issue-81365-11.stderr
+++ b/tests/ui/borrowck/issue-81365-11.stderr
@@ -8,6 +8,6 @@ LL |         self.container_field = true;
 LL |         first;
    |         ----- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-2.stderr b/tests/ui/borrowck/issue-81365-2.stderr
index d9aeaf15f20..f55da67a85b 100644
--- a/tests/ui/borrowck/issue-81365-2.stderr
+++ b/tests/ui/borrowck/issue-81365-2.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = DerefTarget;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-3.stderr b/tests/ui/borrowck/issue-81365-3.stderr
index 0c0d1994baf..f1c24640c13 100644
--- a/tests/ui/borrowck/issue-81365-3.stderr
+++ b/tests/ui/borrowck/issue-81365-3.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = Container;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-4.stderr b/tests/ui/borrowck/issue-81365-4.stderr
index 98093daa945..c0dae0de328 100644
--- a/tests/ui/borrowck/issue-81365-4.stderr
+++ b/tests/ui/borrowck/issue-81365-4.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = Container;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-5.stderr b/tests/ui/borrowck/issue-81365-5.stderr
index 094cec021e4..06c2ea5ab72 100644
--- a/tests/ui/borrowck/issue-81365-5.stderr
+++ b/tests/ui/borrowck/issue-81365-5.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = DerefTarget;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-6.stderr b/tests/ui/borrowck/issue-81365-6.stderr
index e61dc95ecc8..e52ebf9382c 100644
--- a/tests/ui/borrowck/issue-81365-6.stderr
+++ b/tests/ui/borrowck/issue-81365-6.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = [()];
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-7.stderr b/tests/ui/borrowck/issue-81365-7.stderr
index 0565127e387..1933f5bd8d2 100644
--- a/tests/ui/borrowck/issue-81365-7.stderr
+++ b/tests/ui/borrowck/issue-81365-7.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = DerefTarget;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-8.stderr b/tests/ui/borrowck/issue-81365-8.stderr
index 0ca732ff2ae..ab9f71cc00c 100644
--- a/tests/ui/borrowck/issue-81365-8.stderr
+++ b/tests/ui/borrowck/issue-81365-8.stderr
@@ -15,6 +15,6 @@ note: deref defined here
 LL |     type Target = DerefTarget;
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81365-9.stderr b/tests/ui/borrowck/issue-81365-9.stderr
index 4d305268a0b..f0aefd7ba87 100644
--- a/tests/ui/borrowck/issue-81365-9.stderr
+++ b/tests/ui/borrowck/issue-81365-9.stderr
@@ -8,6 +8,6 @@ LL |         self.container_field = true;
 LL |         first;
    |         ----- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/issue-81899.stderr b/tests/ui/borrowck/issue-81899.stderr
index 5ff33933cf0..1da573ea97c 100644
--- a/tests/ui/borrowck/issue-81899.stderr
+++ b/tests/ui/borrowck/issue-81899.stderr
@@ -22,6 +22,6 @@ note: erroneous constant encountered
 LL | const _CONST: &[u8] = &f(&[], |_| {});
    |                       ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/borrowck/issue-82032.stderr b/tests/ui/borrowck/issue-82032.stderr
index f272477a9f5..2ac785cd1e3 100644
--- a/tests/ui/borrowck/issue-82032.stderr
+++ b/tests/ui/borrowck/issue-82032.stderr
@@ -9,6 +9,6 @@ LL |         for v in self.0.values() {
 LL |             v.flush();
    |             ^ `v` is a `&` reference, so the data it refers to cannot be borrowed as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-82462.stderr b/tests/ui/borrowck/issue-82462.stderr
index a2c291f7797..8cb4583eba9 100644
--- a/tests/ui/borrowck/issue-82462.stderr
+++ b/tests/ui/borrowck/issue-82462.stderr
@@ -17,6 +17,6 @@ help: consider adding semicolon after the expression so its temporaries are drop
 LL |     };
    |      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/issue-83309-ice-immut-in-for-loop.stderr b/tests/ui/borrowck/issue-83309-ice-immut-in-for-loop.stderr
index 26ce007dd34..4e7a9b695e1 100644
--- a/tests/ui/borrowck/issue-83309-ice-immut-in-for-loop.stderr
+++ b/tests/ui/borrowck/issue-83309-ice-immut-in-for-loop.stderr
@@ -7,6 +7,6 @@ LL |
 LL |         *v -= 1;
    |         ^^^^^^^ `v` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/borrowck/issue-83924.stderr b/tests/ui/borrowck/issue-83924.stderr
index 572414df2bf..c37de178f24 100644
--- a/tests/ui/borrowck/issue-83924.stderr
+++ b/tests/ui/borrowck/issue-83924.stderr
@@ -17,6 +17,6 @@ help: consider creating a fresh reborrow of `v` here
 LL |     for n in &mut *v {
    |              ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/issue-85581.stderr b/tests/ui/borrowck/issue-85581.stderr
index 29c0429f2a0..80f1f4cb509 100644
--- a/tests/ui/borrowck/issue-85581.stderr
+++ b/tests/ui/borrowck/issue-85581.stderr
@@ -12,6 +12,6 @@ LL |         Some(_) => { heap.pop(); },
 LL | }
    | - ... and the first borrow might be used here, when that temporary is dropped and runs the destructor for type `Option<PeekMut<'_, i32>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/issue-87456-point-to-closure.stderr b/tests/ui/borrowck/issue-87456-point-to-closure.stderr
index afd141125ac..a15909df07b 100644
--- a/tests/ui/borrowck/issue-87456-point-to-closure.stderr
+++ b/tests/ui/borrowck/issue-87456-point-to-closure.stderr
@@ -15,6 +15,6 @@ help: consider borrowing here
 LL |         let _foo: String = &val;
    |                            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/issue-88434-minimal-example.stderr b/tests/ui/borrowck/issue-88434-minimal-example.stderr
index 7b785b25bd0..b32331ce448 100644
--- a/tests/ui/borrowck/issue-88434-minimal-example.stderr
+++ b/tests/ui/borrowck/issue-88434-minimal-example.stderr
@@ -22,6 +22,6 @@ note: erroneous constant encountered
 LL | const _CONST: &() = &f(&|_| {});
    |                     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr b/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr
index 9732b8cfa4d..e3c881dd465 100644
--- a/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr
+++ b/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr
@@ -22,6 +22,6 @@ note: erroneous constant encountered
 LL | const _CONST: &[u8] = &f(&[], |_| {});
    |                       ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/borrowck/issue-91206.stderr b/tests/ui/borrowck/issue-91206.stderr
index 30f83656518..f96b0c7d9e1 100644
--- a/tests/ui/borrowck/issue-91206.stderr
+++ b/tests/ui/borrowck/issue-91206.stderr
@@ -9,6 +9,6 @@ help: consider specifying this binding's type
 LL |     let inner: &mut Vec<usize> = client.get_inner_ref();
    |              +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-92015.stderr b/tests/ui/borrowck/issue-92015.stderr
index ea4f9abb87d..167a5cf5863 100644
--- a/tests/ui/borrowck/issue-92015.stderr
+++ b/tests/ui/borrowck/issue-92015.stderr
@@ -9,6 +9,6 @@ help: consider specifying this binding's type
 LL |     let foo: &mut i32 = Some(&0).unwrap();
    |            ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/borrowck/issue-92157.stderr b/tests/ui/borrowck/issue-92157.stderr
index a46b1288911..0ffedccd690 100644
--- a/tests/ui/borrowck/issue-92157.stderr
+++ b/tests/ui/borrowck/issue-92157.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8) -> isi
    = note: expected signature `fn(fn() -> T, isize, *const *const u8, u8) -> _`
               found signature `fn(fn() -> T, isize, *const *const u8) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/borrowck/issue-93078.stderr b/tests/ui/borrowck/issue-93078.stderr
index bcbcbe72412..446b4582bfb 100644
--- a/tests/ui/borrowck/issue-93078.stderr
+++ b/tests/ui/borrowck/issue-93078.stderr
@@ -7,6 +7,6 @@ LL |         self.modify();
    = note: as `Self` may be unsized, this call attempts to take `&mut &mut self`
    = note: however, `&mut self` expands to `self: &mut Self`, therefore `self` cannot be borrowed mutably
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/issue-93093.stderr b/tests/ui/borrowck/issue-93093.stderr
index afa76594f0b..b6a2768b61d 100644
--- a/tests/ui/borrowck/issue-93093.stderr
+++ b/tests/ui/borrowck/issue-93093.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     async fn bar(&mut self) {
    |                  ~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/borrowck/many-mutable-borrows.stderr b/tests/ui/borrowck/many-mutable-borrows.stderr
index 0f808ac9276..bc2ba987c9d 100644
--- a/tests/ui/borrowck/many-mutable-borrows.stderr
+++ b/tests/ui/borrowck/many-mutable-borrows.stderr
@@ -28,6 +28,6 @@ help: consider changing this to be mutable
 LL |     let mut v = Vec::new();
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/move-error-in-promoted-2.stderr b/tests/ui/borrowck/move-error-in-promoted-2.stderr
index 38dba94bdd4..0d5edadcb46 100644
--- a/tests/ui/borrowck/move-error-in-promoted-2.stderr
+++ b/tests/ui/borrowck/move-error-in-promoted-2.stderr
@@ -7,6 +7,6 @@ LL |     &([S][0],);
    |       cannot move out of here
    |       move occurs because value has type `S`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/borrowck/move-error-in-promoted.stderr b/tests/ui/borrowck/move-error-in-promoted.stderr
index a4432e38da0..03c0297c5a9 100644
--- a/tests/ui/borrowck/move-error-in-promoted.stderr
+++ b/tests/ui/borrowck/move-error-in-promoted.stderr
@@ -7,6 +7,6 @@ LL |     let _ = S1(C[0]).clone();
    |                cannot move out of here
    |                move occurs because value has type `S2`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/borrowck/move-error-snippets.stderr b/tests/ui/borrowck/move-error-snippets.stderr
index 8ac711e9e59..83f9e19aa0d 100644
--- a/tests/ui/borrowck/move-error-snippets.stderr
+++ b/tests/ui/borrowck/move-error-snippets.stderr
@@ -15,6 +15,6 @@ help: consider borrowing here
 LL |         let a = &$c;
    |                 +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/borrowck/move-in-pattern-mut-in-loop.stderr b/tests/ui/borrowck/move-in-pattern-mut-in-loop.stderr
index 55948afca73..bfbae5be050 100644
--- a/tests/ui/borrowck/move-in-pattern-mut-in-loop.stderr
+++ b/tests/ui/borrowck/move-in-pattern-mut-in-loop.stderr
@@ -10,6 +10,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |         if let Some(ref mut _x) = opt {}
    |                     +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/mut-borrow-in-loop-2.stderr b/tests/ui/borrowck/mut-borrow-in-loop-2.stderr
index 74e7067c9af..7b9a946f3ca 100644
--- a/tests/ui/borrowck/mut-borrow-in-loop-2.stderr
+++ b/tests/ui/borrowck/mut-borrow-in-loop-2.stderr
@@ -20,6 +20,6 @@ help: consider creating a fresh reborrow of `value` here
 LL |         Other::handle(&mut *value);
    |                       ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/reborrow-sugg-move-then-borrow.stderr b/tests/ui/borrowck/reborrow-sugg-move-then-borrow.stderr
index ecd916a59fc..8590dd9ca3d 100644
--- a/tests/ui/borrowck/reborrow-sugg-move-then-borrow.stderr
+++ b/tests/ui/borrowck/reborrow-sugg-move-then-borrow.stderr
@@ -16,6 +16,6 @@ help: consider creating a fresh reborrow of `state` here
 LL |     for _ in &mut *state {}
    |              ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/borrowck/regions-escape-bound-fn-2.stderr b/tests/ui/borrowck/regions-escape-bound-fn-2.stderr
index 14393bc8eee..9c070de4457 100644
--- a/tests/ui/borrowck/regions-escape-bound-fn-2.stderr
+++ b/tests/ui/borrowck/regions-escape-bound-fn-2.stderr
@@ -8,6 +8,6 @@ LL |     with_int(|y| x = Some(y));
    |               |
    |               `y` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/borrowck/regions-escape-bound-fn.stderr b/tests/ui/borrowck/regions-escape-bound-fn.stderr
index a23fdacdee6..868ba9c89be 100644
--- a/tests/ui/borrowck/regions-escape-bound-fn.stderr
+++ b/tests/ui/borrowck/regions-escape-bound-fn.stderr
@@ -8,6 +8,6 @@ LL |     with_int(|y| x = Some(y));
    |               |
    |               `y` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/borrowck/regions-escape-unboxed-closure.stderr b/tests/ui/borrowck/regions-escape-unboxed-closure.stderr
index 153f77c8913..c861f772be0 100644
--- a/tests/ui/borrowck/regions-escape-unboxed-closure.stderr
+++ b/tests/ui/borrowck/regions-escape-unboxed-closure.stderr
@@ -8,6 +8,6 @@ LL |     with_int(&mut |y| x = Some(y));
    |                    |
    |                    `y` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/borrowck/return-local-binding-from-desugaring.stderr b/tests/ui/borrowck/return-local-binding-from-desugaring.stderr
index 9f952542e18..1f4a548a4cb 100644
--- a/tests/ui/borrowck/return-local-binding-from-desugaring.stderr
+++ b/tests/ui/borrowck/return-local-binding-from-desugaring.stderr
@@ -7,6 +7,6 @@ LL |     for ref x in xs {
 LL |     result
    |     ^^^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/borrowck/suggest-local-var-for-vector.stderr b/tests/ui/borrowck/suggest-local-var-for-vector.stderr
index c8d00f7b222..d88e8b09687 100644
--- a/tests/ui/borrowck/suggest-local-var-for-vector.stderr
+++ b/tests/ui/borrowck/suggest-local-var-for-vector.stderr
@@ -19,6 +19,6 @@ help: ...and then using that local here
 LL |     vec[vec.len() - 1] = 123;
    |        ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/suggest-mut-iterator.stderr b/tests/ui/borrowck/suggest-mut-iterator.stderr
index 77f991a9a61..b396bb7b5ec 100644
--- a/tests/ui/borrowck/suggest-mut-iterator.stderr
+++ b/tests/ui/borrowck/suggest-mut-iterator.stderr
@@ -11,6 +11,6 @@ help: use a mutable iterator instead
 LL |     for test in &mut tests {
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/borrowck/suggest-storing-local-var-for-vector.stderr b/tests/ui/borrowck/suggest-storing-local-var-for-vector.stderr
index 368d728101c..a69a025cbcb 100644
--- a/tests/ui/borrowck/suggest-storing-local-var-for-vector.stderr
+++ b/tests/ui/borrowck/suggest-storing-local-var-for-vector.stderr
@@ -19,6 +19,6 @@ help: ...and then using that local here
 LL |     vec[vec.len() - 1] = 123;
    |        ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/tainted-promoteds.stderr b/tests/ui/borrowck/tainted-promoteds.stderr
index b276ea9aceb..a5c448fdcdb 100644
--- a/tests/ui/borrowck/tainted-promoteds.stderr
+++ b/tests/ui/borrowck/tainted-promoteds.stderr
@@ -9,6 +9,6 @@ LL |     let a = 0;
 LL |     a = &0 * &1 * &2 * &3;
    |     ^^^^^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/borrowck/two-phase-across-loop.stderr b/tests/ui/borrowck/two-phase-across-loop.stderr
index d7c0210cc77..bd63fc96126 100644
--- a/tests/ui/borrowck/two-phase-across-loop.stderr
+++ b/tests/ui/borrowck/two-phase-across-loop.stderr
@@ -6,6 +6,6 @@ LL |         strings.push(foo.get_string());
    |         |
    |         first borrow used here, in later iteration of loop
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/two-phase-cannot-nest-mut-self-calls.stderr b/tests/ui/borrowck/two-phase-cannot-nest-mut-self-calls.stderr
index 2c3f1c18a08..6a3e0db4be6 100644
--- a/tests/ui/borrowck/two-phase-cannot-nest-mut-self-calls.stderr
+++ b/tests/ui/borrowck/two-phase-cannot-nest-mut-self-calls.stderr
@@ -9,6 +9,6 @@ LL |
 LL |         vec.push(2);
    |         ^^^^^^^^^^^ mutable borrow occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr b/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr
index e3e4057d6a7..b1e4392989f 100644
--- a/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr
+++ b/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr
@@ -10,6 +10,6 @@ LL |         delay = &mut vec;
 LL |         shared[0];
    |         ------ immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/borrowck/two-phase-sneaky.stderr b/tests/ui/borrowck/two-phase-sneaky.stderr
index 4db970c1da0..4f1712ccc00 100644
--- a/tests/ui/borrowck/two-phase-sneaky.stderr
+++ b/tests/ui/borrowck/two-phase-sneaky.stderr
@@ -9,6 +9,6 @@ LL |
 LL |         v.push(format!("foo"));
    |         ^ second mutable borrow occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr b/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr
index a2f6365b74e..fd168b43ac5 100644
--- a/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr
+++ b/tests/ui/borrowck/unboxed-closures-move-upvar-from-non-once-ref-closure.stderr
@@ -17,6 +17,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |         y.clone().into_iter();
    |          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/box/alloc-unstable-fail.stderr b/tests/ui/box/alloc-unstable-fail.stderr
index 03ae36e8890..352efce318f 100644
--- a/tests/ui/box/alloc-unstable-fail.stderr
+++ b/tests/ui/box/alloc-unstable-fail.stderr
@@ -7,6 +7,6 @@ LL |     let _boxed: Box<u32, _> = Box::new(10);
    = note: see issue #32838 <https://github.com/rust-lang/rust/issues/32838> for more information
    = help: add `#![feature(allocator_api)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/box/issue-82446.stderr b/tests/ui/box/issue-82446.stderr
index c03f35884b8..568d23c2cb7 100644
--- a/tests/ui/box/issue-82446.stderr
+++ b/tests/ui/box/issue-82446.stderr
@@ -7,6 +7,6 @@ LL |         val
    = note: expected struct `Box<(dyn MyTrait + 'static)>`
            found reference `&Box<(dyn MyTrait + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/box/leak-alloc.stderr b/tests/ui/box/leak-alloc.stderr
index feda8841fc8..8b8cea3fe84 100644
--- a/tests/ui/box/leak-alloc.stderr
+++ b/tests/ui/box/leak-alloc.stderr
@@ -12,6 +12,6 @@ LL |
 LL |     use_value(*theref)
    |               ------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/box/unit/unique-object-noncopyable.stderr b/tests/ui/box/unit/unique-object-noncopyable.stderr
index db42ed9baf1..1b98d09ccdd 100644
--- a/tests/ui/box/unit/unique-object-noncopyable.stderr
+++ b/tests/ui/box/unit/unique-object-noncopyable.stderr
@@ -20,6 +20,6 @@ LL |       let _z = y.clone();
            `dyn Foo: Clone`
            which is required by `Box<dyn Foo>: Clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/box/unit/unique-pinned-nocopy.stderr b/tests/ui/box/unit/unique-pinned-nocopy.stderr
index 2fd5b0d82e8..d662a2d6d05 100644
--- a/tests/ui/box/unit/unique-pinned-nocopy.stderr
+++ b/tests/ui/box/unit/unique-pinned-nocopy.stderr
@@ -23,6 +23,6 @@ LL + #[derive(Clone)]
 LL | struct R {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/btreemap/btreemap-index-mut-2.stderr b/tests/ui/btreemap/btreemap-index-mut-2.stderr
index c8d4fd59550..0b8c77cb9e1 100644
--- a/tests/ui/btreemap/btreemap-index-mut-2.stderr
+++ b/tests/ui/btreemap/btreemap-index-mut-2.stderr
@@ -14,6 +14,6 @@ LL |         map.get_mut(&0).map(|val| { *val = 1; });
 LL |         let val = map.entry(&0).or_insert(1);
    |         +++++++++    ~~~~~~~  ~~~~~~~~~~~~ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/btreemap/btreemap-index-mut.stderr b/tests/ui/btreemap/btreemap-index-mut.stderr
index 26f2a4c4b29..cc465fbf3de 100644
--- a/tests/ui/btreemap/btreemap-index-mut.stderr
+++ b/tests/ui/btreemap/btreemap-index-mut.stderr
@@ -14,6 +14,6 @@ LL |     map.get_mut(&0).map(|val| { *val = 1; });
 LL |     let val = map.entry(&0).or_insert(1);
    |     +++++++++    ~~~~~~~  ~~~~~~~~~~~~ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/btreemap/btreemap_dropck.stderr b/tests/ui/btreemap/btreemap_dropck.stderr
index d405e465aae..805c2112bdc 100644
--- a/tests/ui/btreemap/btreemap_dropck.stderr
+++ b/tests/ui/btreemap/btreemap_dropck.stderr
@@ -10,6 +10,6 @@ LL |     drop(s);
 LL | }
    | - borrow might be used here, when `_map` is dropped and runs the `Drop` code for type `BTreeMap`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
index f9d548bb8fb..251651df4f9 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
@@ -19,6 +19,6 @@ help: consider further restricting this bound
 LL | impl <T:Sync+'static + std::marker::Send> RequiresRequiresShareAndSend for X<T> { }
    |                      +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
index 0e2c6c60b6e..d0102635315 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
@@ -17,6 +17,6 @@ help: consider adding an explicit lifetime bound
 LL | impl <T: Sync + 'static> Foo for T { }
    |               +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-simple.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-simple.stderr
index 8b19170b0f1..7579bffc72d 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-simple.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-simple.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `Foo`
 LL | trait Foo : Send { }
    |             ^^^^ required by this bound in `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
index 0cfea72d5f1..4a25c42b583 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
@@ -14,6 +14,6 @@ help: consider further restricting this bound
 LL | impl <T: Sync+'static + std::marker::Send> Foo for T { }
    |                       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/c-variadic/issue-32201.stderr b/tests/ui/c-variadic/issue-32201.stderr
index cedb5878466..352db9f62f6 100644
--- a/tests/ui/c-variadic/issue-32201.stderr
+++ b/tests/ui/c-variadic/issue-32201.stderr
@@ -4,6 +4,6 @@ error[E0617]: can't pass `fn(*const u8) {bar}` to variadic function
 LL |         foo(0, bar);
    |                ^^^ help: cast the value to `fn(*const u8)`: `bar as fn(*const u8)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0617`.
diff --git a/tests/ui/c-variadic/issue-86053-2.stderr b/tests/ui/c-variadic/issue-86053-2.stderr
index 815b06e7708..2c4be2522f6 100644
--- a/tests/ui/c-variadic/issue-86053-2.stderr
+++ b/tests/ui/c-variadic/issue-86053-2.stderr
@@ -11,6 +11,6 @@ note: but the referenced data is only valid for the lifetime `'a` as defined her
 LL | unsafe extern "C" fn ordering4<'a, F: H<&'static &'a ()>>(_: (), ...) {}
    |                                ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/c-variadic/variadic-ffi-2.stderr b/tests/ui/c-variadic/variadic-ffi-2.stderr
index 8884fc6fb2a..d0ca7034ba1 100644
--- a/tests/ui/c-variadic/variadic-ffi-2.stderr
+++ b/tests/ui/c-variadic/variadic-ffi-2.stderr
@@ -4,6 +4,6 @@ error[E0045]: C-variadic function must have a compatible calling convention, lik
 LL | fn baz(f: extern "stdcall" fn(usize, ...)) {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0045`.
diff --git a/tests/ui/c-variadic/variadic-ffi-6.stderr b/tests/ui/c-variadic/variadic-ffi-6.stderr
index 4c7792d9650..1ceff570478 100644
--- a/tests/ui/c-variadic/variadic-ffi-6.stderr
+++ b/tests/ui/c-variadic/variadic-ffi-6.stderr
@@ -10,6 +10,6 @@ help: consider using the `'static` lifetime
 LL | ) -> &'static usize {
    |       +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/c-variadic/variadic-ffi-no-fixed-args.stderr b/tests/ui/c-variadic/variadic-ffi-no-fixed-args.stderr
index e11ba43ca2a..e268ef3fa68 100644
--- a/tests/ui/c-variadic/variadic-ffi-no-fixed-args.stderr
+++ b/tests/ui/c-variadic/variadic-ffi-no-fixed-args.stderr
@@ -4,5 +4,5 @@ error: C-variadic function must be declared with at least one named argument
 LL |     fn foo(...);
    |            ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/capture1.stderr b/tests/ui/capture1.stderr
index ad8434709d5..067b85ba619 100644
--- a/tests/ui/capture1.stderr
+++ b/tests/ui/capture1.stderr
@@ -6,6 +6,6 @@ LL |     fn foo() -> isize { return bar; }
    |
    = help: use the `|| { ... }` closure form instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0434`.
diff --git a/tests/ui/cast/cast-errors-issue-43825.stderr b/tests/ui/cast/cast-errors-issue-43825.stderr
index 1e77f5dbdc6..658d5ddbb61 100644
--- a/tests/ui/cast/cast-errors-issue-43825.stderr
+++ b/tests/ui/cast/cast-errors-issue-43825.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `error` in this scope
 LL |     let error = error;
    |                 ^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/cast/cast-from-nil.stderr b/tests/ui/cast/cast-from-nil.stderr
index dab133cfb4b..991ff93a8bd 100644
--- a/tests/ui/cast/cast-from-nil.stderr
+++ b/tests/ui/cast/cast-from-nil.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `()` as `u32`
 LL | fn main() { let u = (assert!(true) as u32); }
    |                     ^^^^^^^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/cast/cast-macro-lhs.stderr b/tests/ui/cast/cast-macro-lhs.stderr
index db7ce57e150..83c6cf31faa 100644
--- a/tests/ui/cast/cast-macro-lhs.stderr
+++ b/tests/ui/cast/cast-macro-lhs.stderr
@@ -6,6 +6,6 @@ LL |     let x = foo!() as *const [u8];
    |             |
    |             consider casting this expression to `*const ()`, then using `core::ptr::from_raw_parts`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/cast/cast-rfc0401-2.stderr b/tests/ui/cast/cast-rfc0401-2.stderr
index dd90c3a9723..b7fb420533e 100644
--- a/tests/ui/cast/cast-rfc0401-2.stderr
+++ b/tests/ui/cast/cast-rfc0401-2.stderr
@@ -9,6 +9,6 @@ help: compare with zero instead
 LL |     let _ = 3 != 0;
    |               ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0054`.
diff --git a/tests/ui/cast/cast-to-nil.stderr b/tests/ui/cast/cast-to-nil.stderr
index 29a9baffd71..14c75983b94 100644
--- a/tests/ui/cast/cast-to-nil.stderr
+++ b/tests/ui/cast/cast-to-nil.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `u32` as `()`
 LL | fn main() { let u = 0u32 as (); }
    |                     ^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/cast/casts-differing-anon.stderr b/tests/ui/cast/casts-differing-anon.stderr
index f9abfb5225f..8ddd97137c3 100644
--- a/tests/ui/cast/casts-differing-anon.stderr
+++ b/tests/ui/cast/casts-differing-anon.stderr
@@ -6,6 +6,6 @@ LL |     b_raw = f_raw as *mut _;
    |
    = note: vtable kinds may not match
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/cast/casts-issue-46365.stderr b/tests/ui/cast/casts-issue-46365.stderr
index 84175473696..84bc73a9b78 100644
--- a/tests/ui/cast/casts-issue-46365.stderr
+++ b/tests/ui/cast/casts-issue-46365.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Ipsum` in this scope
 LL |     ipsum: Ipsum
    |            ^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/cast/issue-10991.stderr b/tests/ui/cast/issue-10991.stderr
index 5b8a1823386..52afc8343e1 100644
--- a/tests/ui/cast/issue-10991.stderr
+++ b/tests/ui/cast/issue-10991.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `()` as `usize`
 LL |     let _t = nil as usize;
    |              ^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/cast/issue-17444.stderr b/tests/ui/cast/issue-17444.stderr
index 1097079dfc1..0d4f6f19431 100644
--- a/tests/ui/cast/issue-17444.stderr
+++ b/tests/ui/cast/issue-17444.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `Test` as `*const isize` is invalid
 LL |     let _x = Test::Foo as *const isize;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/cast/issue-85586.stderr b/tests/ui/cast/issue-85586.stderr
index ed8a6fc62e9..847a5527dda 100644
--- a/tests/ui/cast/issue-85586.stderr
+++ b/tests/ui/cast/issue-85586.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     let b = (a + 1) as usize;
    |             ^^^^^^^ cannot infer type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/cast/issue-88621.stderr b/tests/ui/cast/issue-88621.stderr
index 886145c1baf..0459ce5eabd 100644
--- a/tests/ui/cast/issue-88621.stderr
+++ b/tests/ui/cast/issue-88621.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `Kind2` as `u8`
 LL |     let _ = Kind2::Foo() as u8;
    |             ^^^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/cast/issue-89497.stderr b/tests/ui/cast/issue-89497.stderr
index bf3c3537fad..1208ca45d50 100644
--- a/tests/ui/cast/issue-89497.stderr
+++ b/tests/ui/cast/issue-89497.stderr
@@ -10,6 +10,6 @@ LL -     let _reference: &'static i32 = unsafe { pointer as *const i32 as &'stat
 LL +     let _reference: &'static i32 = unsafe { &*(pointer as *const i32) };
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/cast/unsized-struct-cast.stderr b/tests/ui/cast/unsized-struct-cast.stderr
index 79b3d973c32..47a51d84652 100644
--- a/tests/ui/cast/unsized-struct-cast.stderr
+++ b/tests/ui/cast/unsized-struct-cast.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `&[_; 0]` as `*const Data` is invalid
 LL |     const _: *const Data = &[] as *const Data;
    |                            ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/cast/unsupported-cast.stderr b/tests/ui/cast/unsupported-cast.stderr
index 56a375a1d94..2c4951ec7b1 100644
--- a/tests/ui/cast/unsupported-cast.stderr
+++ b/tests/ui/cast/unsupported-cast.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `f64` as `*const A` is invalid
 LL |   println!("{:?}", 1.0 as *const A);
    |                    ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/cenum_impl_drop_cast.stderr b/tests/ui/cenum_impl_drop_cast.stderr
index b3f921c14ed..541d15d021d 100644
--- a/tests/ui/cenum_impl_drop_cast.stderr
+++ b/tests/ui/cenum_impl_drop_cast.stderr
@@ -12,7 +12,7 @@ note: the lint level is defined here
 LL | #![deny(cenum_impl_drop_cast)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 Future incompatibility report: Future breakage diagnostic:
 error: cannot cast enum `E` into integer `u32` because it implements `Drop`
diff --git a/tests/ui/cfg/diagnostics-not-a-def.stderr b/tests/ui/cfg/diagnostics-not-a-def.stderr
index af0e1a17275..6941f850e5f 100644
--- a/tests/ui/cfg/diagnostics-not-a-def.stderr
+++ b/tests/ui/cfg/diagnostics-not-a-def.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `i_am_not` in module `inner`
 LL |     inner::i_am_not();
    |            ^^^^^^^^ not found in `inner`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/check-static-immutable-mut-slices.stderr b/tests/ui/check-static-immutable-mut-slices.stderr
index a32a94c1315..402f9032b64 100644
--- a/tests/ui/check-static-immutable-mut-slices.stderr
+++ b/tests/ui/check-static-immutable-mut-slices.stderr
@@ -4,6 +4,6 @@ error[E0764]: mutable references are not allowed in the final value of statics
 LL | static TEST: &'static mut [isize] = &mut [];
    |                                     ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0764`.
diff --git a/tests/ui/class-cast-to-trait.stderr b/tests/ui/class-cast-to-trait.stderr
index 56d10d88d8b..4ea0f41c3ed 100644
--- a/tests/ui/class-cast-to-trait.stderr
+++ b/tests/ui/class-cast-to-trait.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `eat` found for struct `Box<dyn Noisy>` in the cur
 LL |   nyan.eat();
    |        ^^^ method not found in `Box<dyn Noisy>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/class-method-missing.stderr b/tests/ui/class-method-missing.stderr
index 3b4ac3a9adc..42bd22e18a1 100644
--- a/tests/ui/class-method-missing.stderr
+++ b/tests/ui/class-method-missing.stderr
@@ -7,6 +7,6 @@ LL |   fn eat(&self);
 LL | impl Animal for Cat {
    | ^^^^^^^^^^^^^^^^^^^ missing `eat` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/closure-expected-type/expect-infer-var-appearing-twice.stderr b/tests/ui/closure-expected-type/expect-infer-var-appearing-twice.stderr
index c5089295063..d3cd8185f92 100644
--- a/tests/ui/closure-expected-type/expect-infer-var-appearing-twice.stderr
+++ b/tests/ui/closure-expected-type/expect-infer-var-appearing-twice.stderr
@@ -16,6 +16,6 @@ LL | fn with_closure<F, A>(_: F)
 LL |     where F: FnOnce(A, A)
    |              ^^^^^^^^^^^^ required by this bound in `with_closure`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr b/tests/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr
index 7a04ed7381e..8799a2a0772 100644
--- a/tests/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr
+++ b/tests/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr
@@ -9,6 +9,6 @@ help: consider giving this closure parameter an explicit type
 LL |     with_closure(|x: u32, y: /* Type */| {});
    |                            ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/closure_context/issue-26046-fn-mut.stderr b/tests/ui/closure_context/issue-26046-fn-mut.stderr
index eeb40945242..0b58180bcca 100644
--- a/tests/ui/closure_context/issue-26046-fn-mut.stderr
+++ b/tests/ui/closure_context/issue-26046-fn-mut.stderr
@@ -11,6 +11,6 @@ LL |     Box::new(closure)
    |
    = note: required for the cast from `Box<{closure@$DIR/issue-26046-fn-mut.rs:4:19: 4:21}>` to `Box<(dyn Fn() + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/closure_context/issue-26046-fn-once.stderr b/tests/ui/closure_context/issue-26046-fn-once.stderr
index 24773a1d7e3..66fb1856cbb 100644
--- a/tests/ui/closure_context/issue-26046-fn-once.stderr
+++ b/tests/ui/closure_context/issue-26046-fn-once.stderr
@@ -11,6 +11,6 @@ LL |     Box::new(closure)
    |
    = note: required for the cast from `Box<{closure@$DIR/issue-26046-fn-once.rs:4:19: 4:26}>` to `Box<(dyn Fn() -> Vec<u8> + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/closure_context/issue-42065.stderr b/tests/ui/closure_context/issue-42065.stderr
index 896bb6dc6be..9ae89047d12 100644
--- a/tests/ui/closure_context/issue-42065.stderr
+++ b/tests/ui/closure_context/issue-42065.stderr
@@ -17,6 +17,6 @@ note: this value implements `FnOnce`, which causes it to be moved when called
 LL |     debug_dump_dict();
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-1.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-1.stderr
index 341d2bc6563..f59a2625cd2 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-1.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-1.stderr
@@ -14,6 +14,6 @@ LL |        println!("{:?}", p);
 LL |     *y+=1;
    |     ----- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-2.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-2.stderr
index 584bb862b2c..64d5ff8e2e0 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-2.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-2.stderr
@@ -14,6 +14,6 @@ LL |        let x = &mut p.x;
 LL |     println!("{}", y);
    |                    - immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-3.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-3.stderr
index ee923804786..979527e9f79 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-3.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-3.stderr
@@ -17,6 +17,6 @@ help: to force the closure to take ownership of `p` (and any other referenced va
 LL |         move || {
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-4.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-4.stderr
index 46379a3815a..d47f0539b84 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-4.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-4.stderr
@@ -17,6 +17,6 @@ help: to force the closure to take ownership of `p` (and any other referenced va
 LL |     let mut c = move || {
    |                 ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-closures-mut-and-imm.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-closures-mut-and-imm.stderr
index 5f1dae2972f..57234fffec6 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-closures-mut-and-imm.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/borrowck/borrowck-closures-mut-and-imm.stderr
@@ -16,6 +16,6 @@ LL |     };
 LL |     drop(c2);
    |          -- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/cant-mutate-imm-borrow.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/cant-mutate-imm-borrow.stderr
index 38c530b809a..d224f21bc84 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/cant-mutate-imm-borrow.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/cant-mutate-imm-borrow.stderr
@@ -7,6 +7,6 @@ LL |
 LL |         z.0.0.0 = format!("X1");
    |         ------- mutable borrow occurs due to use of `*z.0.0` in closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-array-diagnostics.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-array-diagnostics.stderr
index 309c63e5293..1172f54c150 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-array-diagnostics.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-array-diagnostics.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `expect_fn`
 LL | fn expect_fn<F: Fn()>(_f: F) {}
    |                 ^^^^ required by this bound in `expect_fn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-multi-variant-diagnostics.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-multi-variant-diagnostics.stderr
index 83d282aadb9..347fa3fa892 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-multi-variant-diagnostics.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-multi-variant-diagnostics.stderr
@@ -16,6 +16,6 @@ help: consider mutably borrowing `c`
 LL |     let a = &mut c;
    |             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-single-variant-diagnostics.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-single-variant-diagnostics.stderr
index 46323b75210..c9b27e76879 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-single-variant-diagnostics.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-single-variant-diagnostics.stderr
@@ -16,6 +16,6 @@ help: consider mutably borrowing `c`
 LL |     let b = &mut c;
    |             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-struct-diagnostics.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-struct-diagnostics.stderr
index 25029cc7bd8..079a9abedf9 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-struct-diagnostics.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-struct-diagnostics.stderr
@@ -16,6 +16,6 @@ help: consider mutably borrowing `hello`
 LL |     let b = &mut hello;
    |             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics-1.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics-1.stderr
index 06ef7baf9c0..0bf717404ce 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics-1.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics-1.stderr
@@ -16,6 +16,6 @@ help: consider mutably borrowing `hello`
 LL |     let b = &mut hello;
    |             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics.stderr
index 3e77635f9e0..4abe5eda22d 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/closure-origin-tuple-diagnostics.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `expect_fn`
 LL | fn expect_fn<F: Fn()>(_f: F) {}
    |                 ^^^^ required by this bound in `expect_fn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/multilevel-path.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/multilevel-path.stderr
index ac4c9c93769..5a054ef5fdc 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/multilevel-path.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/multilevel-path.stderr
@@ -12,6 +12,6 @@ LL |
 LL |     c();
    |     - first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/repr_packed.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/repr_packed.stderr
index 8c44229bceb..c9972c8e7e3 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/repr_packed.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/repr_packed.stderr
@@ -9,6 +9,6 @@ LL |         println!("{}", foo.x);
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0793`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/simple-struct-min-capture.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/simple-struct-min-capture.stderr
index 06157b2af7a..68fdb3ce131 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/simple-struct-min-capture.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/simple-struct-min-capture.stderr
@@ -16,6 +16,6 @@ LL |     c();
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/union.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/union.stderr
index 17834e61236..63fb3e5d975 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/union.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/union.stderr
@@ -13,6 +13,6 @@ LL |     a.y = 1;
 LL |     c();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/closures/2229_closure_analysis/issue-90465.stderr b/tests/ui/closures/2229_closure_analysis/issue-90465.stderr
index c1679c6b637..ccca24764e4 100644
--- a/tests/ui/closures/2229_closure_analysis/issue-90465.stderr
+++ b/tests/ui/closures/2229_closure_analysis/issue-90465.stderr
@@ -22,5 +22,5 @@ LL ~     let c0 = move || {
 LL +         let _ = &f0;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/2229_closure_analysis/match/match-edge-cases_2.stderr b/tests/ui/closures/2229_closure_analysis/match/match-edge-cases_2.stderr
index 1e42d73c62b..d82db0481a0 100644
--- a/tests/ui/closures/2229_closure_analysis/match/match-edge-cases_2.stderr
+++ b/tests/ui/closures/2229_closure_analysis/match/match-edge-cases_2.stderr
@@ -12,6 +12,6 @@ LL |
 LL |     _b();
    |     -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/closures/2229_closure_analysis/migrations/macro.stderr b/tests/ui/closures/2229_closure_analysis/migrations/macro.stderr
index c17edce72f9..7ea5136d119 100644
--- a/tests/ui/closures/2229_closure_analysis/migrations/macro.stderr
+++ b/tests/ui/closures/2229_closure_analysis/migrations/macro.stderr
@@ -18,5 +18,5 @@ help: add a dummy let to cause `a` to be fully captured
 LL |     let _ = || { let _ = &a; dbg!(a.0) };
    |                +++++++++++++           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr b/tests/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
index e10898f9844..2b76deca377 100644
--- a/tests/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
+++ b/tests/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
@@ -22,5 +22,5 @@ LL ~     let result = panic::catch_unwind(move || {
 LL +         let _ = &f;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-1.stderr b/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-1.stderr
index 730823281ab..e4b5d39c0b1 100644
--- a/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-1.stderr
+++ b/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-1.stderr
@@ -10,5 +10,5 @@ LL |     let mut closure = |input| x.0 = input;
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-2.stderr b/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-2.stderr
index 66ba0fe3547..c18649b9ee9 100644
--- a/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-2.stderr
+++ b/tests/ui/closures/2229_closure_analysis/unique-borrows-are-invariant-2.stderr
@@ -11,5 +11,5 @@ LL |                 self.borrowed = borrow;
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/add_semicolon_non_block_closure.stderr b/tests/ui/closures/add_semicolon_non_block_closure.stderr
index 6f9c309edda..d095e59c7eb 100644
--- a/tests/ui/closures/add_semicolon_non_block_closure.stderr
+++ b/tests/ui/closures/add_semicolon_non_block_closure.stderr
@@ -11,6 +11,6 @@ help: consider using a semicolon here
 LL |     foo(|| { bar(); })
    |            +      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/binder/const-bound.stderr b/tests/ui/closures/binder/const-bound.stderr
index c016465c101..9c4fd95ed76 100644
--- a/tests/ui/closures/binder/const-bound.stderr
+++ b/tests/ui/closures/binder/const-bound.stderr
@@ -13,5 +13,5 @@ error: late-bound const parameter not allowed on closures
 LL |     for<const N: i32> || -> () {};
    |         ^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/closures/binder/disallow-const.stderr b/tests/ui/closures/binder/disallow-const.stderr
index 59f299315f8..d38b233d99a 100644
--- a/tests/ui/closures/binder/disallow-const.stderr
+++ b/tests/ui/closures/binder/disallow-const.stderr
@@ -7,6 +7,6 @@ LL |     for<const N: i32> || -> () {};
    = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
    = help: add `#![feature(non_lifetime_binders)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/closures/binder/disallow-ty.stderr b/tests/ui/closures/binder/disallow-ty.stderr
index 3370e21bd71..bc6696ad36b 100644
--- a/tests/ui/closures/binder/disallow-ty.stderr
+++ b/tests/ui/closures/binder/disallow-ty.stderr
@@ -7,6 +7,6 @@ LL |     for<T> || -> () {};
    = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
    = help: add `#![feature(non_lifetime_binders)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/closures/binder/implicit-return.stderr b/tests/ui/closures/binder/implicit-return.stderr
index 35db34ce21d..ff39e8841ee 100644
--- a/tests/ui/closures/binder/implicit-return.stderr
+++ b/tests/ui/closures/binder/implicit-return.stderr
@@ -6,5 +6,5 @@ LL |     let _f = for<'a> |_: &'a ()| {};
    |              |
    |              `for<...>` is here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/closures/binder/type-bound-2.stderr b/tests/ui/closures/binder/type-bound-2.stderr
index 14b2dbf0395..6609b326f19 100644
--- a/tests/ui/closures/binder/type-bound-2.stderr
+++ b/tests/ui/closures/binder/type-bound-2.stderr
@@ -13,5 +13,5 @@ error: late-bound type parameter not allowed on closures
 LL |     for<T> || -> () {};
    |         ^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/closures/binder/type-bound.stderr b/tests/ui/closures/binder/type-bound.stderr
index ef00a2dffce..22431130a5d 100644
--- a/tests/ui/closures/binder/type-bound.stderr
+++ b/tests/ui/closures/binder/type-bound.stderr
@@ -13,5 +13,5 @@ error: late-bound type parameter not allowed on closures
 LL |     for<T> || -> T {};
    |         ^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/closures/cannot-call-unsized-via-ptr.stderr b/tests/ui/closures/cannot-call-unsized-via-ptr.stderr
index 9ecc66d5ce8..7c73372e33c 100644
--- a/tests/ui/closures/cannot-call-unsized-via-ptr.stderr
+++ b/tests/ui/closures/cannot-call-unsized-via-ptr.stderr
@@ -7,6 +7,6 @@ LL |     let f: fn([u8]) = |_result| {};
    = help: the trait `Sized` is not implemented for `[u8]`
    = note: all function arguments must have a statically known size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/capture-unsized-by-move.stderr b/tests/ui/closures/capture-unsized-by-move.stderr
index d7fafc8cadd..686bbab8839 100644
--- a/tests/ui/closures/capture-unsized-by-move.stderr
+++ b/tests/ui/closures/capture-unsized-by-move.stderr
@@ -9,6 +9,6 @@ LL |         k.to_string();
    = help: the trait `Sized` is not implemented for `(dyn std::fmt::Display + 'static)`
    = note: all values captured by value by a closure must have a statically known size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
index bf6ec5c36e4..e98f05b470e 100644
--- a/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
+++ b/tests/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
@@ -14,6 +14,6 @@ help: consider further restricting this bound
 LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
    |                                                       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/closure-bounds-subtype.stderr b/tests/ui/closures/closure-bounds-subtype.stderr
index 8ad8273fc2b..42588668e8a 100644
--- a/tests/ui/closures/closure-bounds-subtype.stderr
+++ b/tests/ui/closures/closure-bounds-subtype.stderr
@@ -20,6 +20,6 @@ help: consider further restricting this bound
 LL | fn give_owned<F>(f: F) where F: FnOnce() + Send + std::marker::Sync {
    |                                                 +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/closure-expected.stderr b/tests/ui/closures/closure-expected.stderr
index 565038f5144..6b309d70bdf 100644
--- a/tests/ui/closures/closure-expected.stderr
+++ b/tests/ui/closures/closure-expected.stderr
@@ -11,6 +11,6 @@ LL |     let y = x.or_else(4);
 note: required by a bound in `Option::<T>::or_else`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/closure-immutable-outer-variable.stderr b/tests/ui/closures/closure-immutable-outer-variable.stderr
index 799097889cd..23bd0020db6 100644
--- a/tests/ui/closures/closure-immutable-outer-variable.stderr
+++ b/tests/ui/closures/closure-immutable-outer-variable.stderr
@@ -6,6 +6,6 @@ LL |     let y = true;
 LL |     foo(Box::new(move || y = !y) as Box<_>);
    |                          ^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/closures/closure-move-sync.stderr b/tests/ui/closures/closure-move-sync.stderr
index aee903ac950..2bb26b0c0b7 100644
--- a/tests/ui/closures/closure-move-sync.stderr
+++ b/tests/ui/closures/closure-move-sync.stderr
@@ -20,6 +20,6 @@ LL |     let t = thread::spawn(|| {
 note: required by a bound in `spawn`
   --> $SRC_DIR/std/src/thread/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/closure-no-fn-1.stderr b/tests/ui/closures/closure-no-fn-1.stderr
index 87e670bb0b3..8fab92e9b15 100644
--- a/tests/ui/closures/closure-no-fn-1.stderr
+++ b/tests/ui/closures/closure-no-fn-1.stderr
@@ -14,6 +14,6 @@ note: closures can only be coerced to `fn` types if they do not capture any vari
 LL |     let foo: fn(u8) -> u8 = |v: u8| { a += v; a };
    |                                       ^ `a` captured here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/closure-no-fn-2.stderr b/tests/ui/closures/closure-no-fn-2.stderr
index 7c7e9d0ce12..06682fcc244 100644
--- a/tests/ui/closures/closure-no-fn-2.stderr
+++ b/tests/ui/closures/closure-no-fn-2.stderr
@@ -14,6 +14,6 @@ note: closures can only be coerced to `fn` types if they do not capture any vari
 LL |     let bar: fn() -> u8 = || { b };
    |                                ^ `b` captured here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/closure-no-fn-3.stderr b/tests/ui/closures/closure-no-fn-3.stderr
index 276e766e806..bbf3677fb72 100644
--- a/tests/ui/closures/closure-no-fn-3.stderr
+++ b/tests/ui/closures/closure-no-fn-3.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `{closure@$DIR/closure-no-fn-3.rs:6:28: 6:30}`
 LL |     let baz: fn() -> u8 = (|| { b }) as fn() -> u8;
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ invalid cast
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/closures/closure-no-fn-4.stderr b/tests/ui/closures/closure-no-fn-4.stderr
index 0bec11ab61f..c86731b127d 100644
--- a/tests/ui/closures/closure-no-fn-4.stderr
+++ b/tests/ui/closures/closure-no-fn-4.stderr
@@ -19,6 +19,6 @@ note: closures can only be coerced to `fn` types if they do not capture any vari
 LL |         false => |a| a - b,
    |                          ^ `b` captured here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/closure-no-fn-5.stderr b/tests/ui/closures/closure-no-fn-5.stderr
index 13d19495d23..ffe01fac496 100644
--- a/tests/ui/closures/closure-no-fn-5.stderr
+++ b/tests/ui/closures/closure-no-fn-5.stderr
@@ -18,6 +18,6 @@ LL |     let bar: fn() -> u8 = || { a; b; c; d; e };
    |                                |  `b` captured here
    |                                `a` captured here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/closure-referencing-itself-issue-25954.stderr b/tests/ui/closures/closure-referencing-itself-issue-25954.stderr
index 8ca43cd1cff..6fe6840b35b 100644
--- a/tests/ui/closures/closure-referencing-itself-issue-25954.stderr
+++ b/tests/ui/closures/closure-referencing-itself-issue-25954.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     let q = || p.b.set(5i32);
    |             ^^^^^^^^^^^^^^^^ cyclic type of infinite size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/closure-reform-bad.stderr b/tests/ui/closures/closure-reform-bad.stderr
index 6bb59813157..42693066606 100644
--- a/tests/ui/closures/closure-reform-bad.stderr
+++ b/tests/ui/closures/closure-reform-bad.stderr
@@ -21,6 +21,6 @@ note: function defined here
 LL | fn call_bare(f: fn(&str)) {
    |    ^^^^^^^^^ -----------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/closure-wrong-kind.stderr b/tests/ui/closures/closure-wrong-kind.stderr
index 9ea55d764f3..705cc948668 100644
--- a/tests/ui/closures/closure-wrong-kind.stderr
+++ b/tests/ui/closures/closure-wrong-kind.stderr
@@ -16,6 +16,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Fn(u32)>(_: T) {}
    |           ^^^^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.mir.stderr b/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.mir.stderr
index a60100ddaea..57922770310 100644
--- a/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.mir.stderr
+++ b/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.mir.stderr
@@ -6,6 +6,6 @@ LL |     let _: unsafe fn() = || { ::std::pin::Pin::new_unchecked(&0_u8); };
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.thir.stderr b/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.thir.stderr
index 8c516e8900c..fb237231d65 100644
--- a/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.thir.stderr
+++ b/tests/ui/closures/coerce-unsafe-closure-to-unsafe-fn-ptr.thir.stderr
@@ -6,6 +6,6 @@ LL |     let _: unsafe fn() = || { ::std::pin::Pin::new_unchecked(&0_u8); };
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/closures/coerce-unsafe-to-closure.stderr b/tests/ui/closures/coerce-unsafe-to-closure.stderr
index bd4ab13a205..4841ff32e70 100644
--- a/tests/ui/closures/coerce-unsafe-to-closure.stderr
+++ b/tests/ui/closures/coerce-unsafe-to-closure.stderr
@@ -11,6 +11,6 @@ LL |     let x: Option<&[u8]> = Some("foo").map(std::mem::transmute);
 note: required by a bound in `Option::<T>::map`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/infer-signature-from-impl.next.stderr b/tests/ui/closures/infer-signature-from-impl.next.stderr
index 97351706699..0866265cf04 100644
--- a/tests/ui/closures/infer-signature-from-impl.next.stderr
+++ b/tests/ui/closures/infer-signature-from-impl.next.stderr
@@ -11,6 +11,6 @@ help: consider giving this closure parameter an explicit type
 LL |     needs_foo(|x: /* Type */| {
    |                 ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/closures/issue-10398.stderr b/tests/ui/closures/issue-10398.stderr
index 423b79dafcc..bcbcd6d4c2d 100644
--- a/tests/ui/closures/issue-10398.stderr
+++ b/tests/ui/closures/issue-10398.stderr
@@ -8,6 +8,6 @@ LL |         drop(x);
    |
    = note: move occurs because `x` has type `Box<i32>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/issue-112547.stderr b/tests/ui/closures/issue-112547.stderr
index d86b05dc6a7..f47ea607297 100644
--- a/tests/ui/closures/issue-112547.stderr
+++ b/tests/ui/closures/issue-112547.stderr
@@ -18,6 +18,6 @@ LL | #![feature(non_lifetime_binders)]
    = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/closures/issue-113087.stderr b/tests/ui/closures/issue-113087.stderr
index 8ccef4a54f5..c51d13f4ad0 100644
--- a/tests/ui/closures/issue-113087.stderr
+++ b/tests/ui/closures/issue-113087.stderr
@@ -11,6 +11,6 @@ LL |         });
 LL |     }
    |     - `a` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/closures/issue-11873.stderr b/tests/ui/closures/issue-11873.stderr
index c814eedd226..04921b9227e 100644
--- a/tests/ui/closures/issue-11873.stderr
+++ b/tests/ui/closures/issue-11873.stderr
@@ -11,6 +11,6 @@ LL |
 LL |     f();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/closures/issue-25439.stderr b/tests/ui/closures/issue-25439.stderr
index 5e889e6c184..19a26396a5d 100644
--- a/tests/ui/closures/issue-25439.stderr
+++ b/tests/ui/closures/issue-25439.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `fix`
 LL | fn fix<F>(f: F) -> i32 where F: Fn(Helper<F>, i32) -> i32 {
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `fix`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0644`.
diff --git a/tests/ui/closures/issue-67123.stderr b/tests/ui/closures/issue-67123.stderr
index 7877c7334d7..bdafeaef15f 100644
--- a/tests/ui/closures/issue-67123.stderr
+++ b/tests/ui/closures/issue-67123.stderr
@@ -12,6 +12,6 @@ help: consider restricting type parameter `T`
 LL | fn foo<T: Copy>(t: T) {
    |         ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/issue-6801.stderr b/tests/ui/closures/issue-6801.stderr
index 6a40db0d51d..aed673fe1ab 100644
--- a/tests/ui/closures/issue-6801.stderr
+++ b/tests/ui/closures/issue-6801.stderr
@@ -11,6 +11,6 @@ LL |       twice(x);
 LL |       invoke(sq);
    |              -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/closures/issue-80313-mutable-borrow-in-closure.stderr b/tests/ui/closures/issue-80313-mutable-borrow-in-closure.stderr
index 239f071ca92..1266c603e5d 100644
--- a/tests/ui/closures/issue-80313-mutable-borrow-in-closure.stderr
+++ b/tests/ui/closures/issue-80313-mutable-borrow-in-closure.stderr
@@ -12,6 +12,6 @@ help: consider changing this to be mutable
 LL |     let mut callback = || {
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-80313-mutable-borrow-in-move-closure.stderr b/tests/ui/closures/issue-80313-mutable-borrow-in-move-closure.stderr
index 1ec279f03ef..57320b58d01 100644
--- a/tests/ui/closures/issue-80313-mutable-borrow-in-move-closure.stderr
+++ b/tests/ui/closures/issue-80313-mutable-borrow-in-move-closure.stderr
@@ -12,6 +12,6 @@ help: consider changing this to be mutable
 LL |     let mut callback = move || {
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-80313-mutation-in-closure.stderr b/tests/ui/closures/issue-80313-mutation-in-closure.stderr
index 22a62ce7350..b605cd2f9e5 100644
--- a/tests/ui/closures/issue-80313-mutation-in-closure.stderr
+++ b/tests/ui/closures/issue-80313-mutation-in-closure.stderr
@@ -12,6 +12,6 @@ help: consider changing this to be mutable
 LL |     let mut callback = || {
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-80313-mutation-in-move-closure.stderr b/tests/ui/closures/issue-80313-mutation-in-move-closure.stderr
index a2222f8cc95..b0210ac7cb7 100644
--- a/tests/ui/closures/issue-80313-mutation-in-move-closure.stderr
+++ b/tests/ui/closures/issue-80313-mutation-in-move-closure.stderr
@@ -12,6 +12,6 @@ help: consider changing this to be mutable
 LL |     let mut callback = move || {
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-81700-mut-borrow.stderr b/tests/ui/closures/issue-81700-mut-borrow.stderr
index 03b18c3f70c..d050fb60c3d 100644
--- a/tests/ui/closures/issue-81700-mut-borrow.stderr
+++ b/tests/ui/closures/issue-81700-mut-borrow.stderr
@@ -11,6 +11,6 @@ help: consider changing this to be mutable
 LL |     let mut bar = || { foo(x); };
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-82438-mut-without-upvar.stderr b/tests/ui/closures/issue-82438-mut-without-upvar.stderr
index f0951b7d108..c6ed7097c5d 100644
--- a/tests/ui/closures/issue-82438-mut-without-upvar.stderr
+++ b/tests/ui/closures/issue-82438-mut-without-upvar.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut c = |a, b, c, d| {};
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-84044-drop-non-mut.stderr b/tests/ui/closures/issue-84044-drop-non-mut.stderr
index 5335a056cd8..ada0e337324 100644
--- a/tests/ui/closures/issue-84044-drop-non-mut.stderr
+++ b/tests/ui/closures/issue-84044-drop-non-mut.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut f = || {};
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/closures/issue-84128.stderr b/tests/ui/closures/issue-84128.stderr
index 1cd8949b8c4..9d4c7f71581 100644
--- a/tests/ui/closures/issue-84128.stderr
+++ b/tests/ui/closures/issue-84128.stderr
@@ -19,6 +19,6 @@ note: tuple struct defined here
 LL | struct Foo<T>(T);
    |        ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/issue-99565.stderr b/tests/ui/closures/issue-99565.stderr
index 0d940aa9a2f..e48f5106165 100644
--- a/tests/ui/closures/issue-99565.stderr
+++ b/tests/ui/closures/issue-99565.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |     foo::<T, _>(|| {});
    |        ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/closures/multiple-fn-bounds.stderr b/tests/ui/closures/multiple-fn-bounds.stderr
index d94c902f721..d510fc585f6 100644
--- a/tests/ui/closures/multiple-fn-bounds.stderr
+++ b/tests/ui/closures/multiple-fn-bounds.stderr
@@ -23,6 +23,6 @@ help: consider adjusting the signature so it does not borrow its argument
 LL |     foo(move |char| v);
    |               ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/closures/old-closure-expression-remove-semicolon.stderr b/tests/ui/closures/old-closure-expression-remove-semicolon.stderr
index bc54ab4d511..c6ce1c62d93 100644
--- a/tests/ui/closures/old-closure-expression-remove-semicolon.stderr
+++ b/tests/ui/closures/old-closure-expression-remove-semicolon.stderr
@@ -9,6 +9,6 @@ LL | |         foo();
 LL | |     };
    | |_____^ expected `i32`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/print/closure-print-generic-1.stderr b/tests/ui/closures/print/closure-print-generic-1.stderr
index 2697f93b14c..41cad279f7b 100644
--- a/tests/ui/closures/print/closure-print-generic-1.stderr
+++ b/tests/ui/closures/print/closure-print-generic-1.stderr
@@ -15,6 +15,6 @@ note: this value implements `FnOnce`, which causes it to be moved when called
 LL |     c();
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/print/closure-print-generic-2.stderr b/tests/ui/closures/print/closure-print-generic-2.stderr
index ced0be9458b..0a604a7d6cf 100644
--- a/tests/ui/closures/print/closure-print-generic-2.stderr
+++ b/tests/ui/closures/print/closure-print-generic-2.stderr
@@ -15,6 +15,6 @@ help: use parentheses to call this closure
 LL |         let c1: () = c();
    |                       ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr b/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
index 6e3659b95ea..1a13255429f 100644
--- a/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
+++ b/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
@@ -15,6 +15,6 @@ help: use parentheses to call this closure
 LL |         let c1 : () = c();
    |                        ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/print/closure-print-generic-verbose-1.stderr b/tests/ui/closures/print/closure-print-generic-verbose-1.stderr
index 5e8a6b1a73a..75aa3c93479 100644
--- a/tests/ui/closures/print/closure-print-generic-verbose-1.stderr
+++ b/tests/ui/closures/print/closure-print-generic-verbose-1.stderr
@@ -15,6 +15,6 @@ note: this value implements `FnOnce`, which causes it to be moved when called
 LL |     c();
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/closures/print/closure-print-generic-verbose-2.stderr b/tests/ui/closures/print/closure-print-generic-verbose-2.stderr
index f1fc35e755c..8553817247d 100644
--- a/tests/ui/closures/print/closure-print-generic-verbose-2.stderr
+++ b/tests/ui/closures/print/closure-print-generic-verbose-2.stderr
@@ -15,6 +15,6 @@ help: use parentheses to call this closure
 LL |         let c1 : () = c();
    |                        ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/closures/print/closure-print-verbose.stderr b/tests/ui/closures/print/closure-print-verbose.stderr
index 3f9160fe5fa..3d0af5eb171 100644
--- a/tests/ui/closures/print/closure-print-verbose.stderr
+++ b/tests/ui/closures/print/closure-print-verbose.stderr
@@ -14,6 +14,6 @@ note: closures can only be coerced to `fn` types if they do not capture any vari
 LL |     let foo: fn(u8) -> u8 = |v: u8| { a += v; a };
    |                                       ^ `a` captured here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
index ed8e16899a1..0a5884d38f7 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
@@ -7,6 +7,6 @@ LL |         core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32
    = note: see issue #81391 <https://github.com/rust-lang/rust/issues/81391> for more information
    = help: add `#![feature(abi_c_cmse_nonsecure_call)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-on-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-on-stack.stderr
index 37230078781..a8aced2483e 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-on-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-on-stack.stderr
@@ -1,4 +1,4 @@
 error: <unknown>:0:0: in function test i32 (i32, i32, i32, i32, i32): call to non-secure function would require passing arguments on stack
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
index 08b763b2608..8d1b10eaeb5 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
@@ -4,6 +4,6 @@ error[E0781]: the `"C-cmse-nonsecure-call"` ABI is only allowed on function poin
 LL | pub extern "C-cmse-nonsecure-call" fn test() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0781`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
index 3ade9891e48..917098e21d8 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
@@ -6,6 +6,6 @@ LL | |     fn test();
 LL | | }
    | |_^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0781`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/issue-83475.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/issue-83475.stderr
index 426d82d8d07..26d3bfe7837 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/issue-83475.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/issue-83475.stderr
@@ -7,5 +7,5 @@ LL |
 LL | struct XEmpty2;
    | --------------- not a function definition
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-on-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-on-stack.stderr
index 1054c266512..cfbdda509e5 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-on-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-on-stack.stderr
@@ -1,4 +1,4 @@
 error: <unknown>:0:0: in function entry_function i32 (i32, i32, i32, i32, i32): secure entry function requires arguments on stack
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.stderr
index 7e8862f9ab7..3e6954394f4 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.stderr
@@ -4,6 +4,6 @@ error[E0775]: `#[cmse_nonsecure_entry]` is only valid for targets with the Trust
 LL | #[cmse_nonsecure_entry]
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0775`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/wrong-abi.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/wrong-abi.stderr
index 36d76c9674a..4d34f0d7509 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/wrong-abi.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/wrong-abi.stderr
@@ -4,6 +4,6 @@ error[E0776]: `#[cmse_nonsecure_entry]` requires C ABI
 LL | #[cmse_nonsecure_entry]
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0776`.
diff --git a/tests/ui/codemap_tests/coherence-overlapping-inherent-impl-trait.stderr b/tests/ui/codemap_tests/coherence-overlapping-inherent-impl-trait.stderr
index 2c1c3c2dc96..917ea7330a1 100644
--- a/tests/ui/codemap_tests/coherence-overlapping-inherent-impl-trait.stderr
+++ b/tests/ui/codemap_tests/coherence-overlapping-inherent-impl-trait.stderr
@@ -6,6 +6,6 @@ LL | impl dyn C { fn f() {} }
 LL | impl dyn C { fn f() {} }
    |              ------ other definition for `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/codemap_tests/empty_span.stderr b/tests/ui/codemap_tests/empty_span.stderr
index e36f59ee546..32f51c95d44 100644
--- a/tests/ui/codemap_tests/empty_span.stderr
+++ b/tests/ui/codemap_tests/empty_span.stderr
@@ -4,6 +4,6 @@ error[E0321]: cross-crate traits with a default impl, like `Send`, can only be i
 LL |     unsafe impl Send for &'static Foo { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0321`.
diff --git a/tests/ui/codemap_tests/huge_multispan_highlight.stderr b/tests/ui/codemap_tests/huge_multispan_highlight.stderr
index 9f8ce3b6183..d2923875c94 100644
--- a/tests/ui/codemap_tests/huge_multispan_highlight.stderr
+++ b/tests/ui/codemap_tests/huge_multispan_highlight.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut x = "foo";
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/codemap_tests/issue-11715.stderr b/tests/ui/codemap_tests/issue-11715.stderr
index d0c29c768eb..5d0cf718761 100644
--- a/tests/ui/codemap_tests/issue-11715.stderr
+++ b/tests/ui/codemap_tests/issue-11715.stderr
@@ -9,6 +9,6 @@ LL |     z.use_mut();
 LL |     y.use_mut();
    |     - first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/codemap_tests/issue-28308.stderr b/tests/ui/codemap_tests/issue-28308.stderr
index 7daa0510cfa..efd8fa22fa5 100644
--- a/tests/ui/codemap_tests/issue-28308.stderr
+++ b/tests/ui/codemap_tests/issue-28308.stderr
@@ -6,6 +6,6 @@ LL |     assert!("foo");
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/codemap_tests/one_line.stderr b/tests/ui/codemap_tests/one_line.stderr
index 75fbbada72c..90762b87b5c 100644
--- a/tests/ui/codemap_tests/one_line.stderr
+++ b/tests/ui/codemap_tests/one_line.stderr
@@ -18,6 +18,6 @@ help: ...and then using that local as the argument to this call
 LL |     v.push(v.pop().unwrap());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/codemap_tests/tab_2.stderr b/tests/ui/codemap_tests/tab_2.stderr
index 0bfdc3ac265..4f9a937155d 100644
--- a/tests/ui/codemap_tests/tab_2.stderr
+++ b/tests/ui/codemap_tests/tab_2.stderr
@@ -6,6 +6,6 @@ LL |                   """;
 LL | | }
    | |__^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0765`.
diff --git a/tests/ui/codemap_tests/tab_3.stderr b/tests/ui/codemap_tests/tab_3.stderr
index b17159be6e0..7ae21a57052 100644
--- a/tests/ui/codemap_tests/tab_3.stderr
+++ b/tests/ui/codemap_tests/tab_3.stderr
@@ -17,6 +17,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |     some_vec.clone().into_iter();
    |             ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/codemap_tests/two_files.stderr b/tests/ui/codemap_tests/two_files.stderr
index 2eb3fd56783..d833d4944bf 100644
--- a/tests/ui/codemap_tests/two_files.stderr
+++ b/tests/ui/codemap_tests/two_files.stderr
@@ -10,6 +10,6 @@ help: you might have meant to use `#![feature(trait_alias)]` instead of a `type`
 LL | trait Bar = dyn Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/codemap_tests/unicode.normal.stderr b/tests/ui/codemap_tests/unicode.normal.stderr
index 05ceb6910da..a6e22e1c38f 100644
--- a/tests/ui/codemap_tests/unicode.normal.stderr
+++ b/tests/ui/codemap_tests/unicode.normal.stderr
@@ -6,6 +6,6 @@ LL | extern "路濫狼á́́" fn foo() {}
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0703`.
diff --git a/tests/ui/coercion/coerce-block-tail-26978.stderr b/tests/ui/coercion/coerce-block-tail-26978.stderr
index 90eb75f2bdf..89682e103aa 100644
--- a/tests/ui/coercion/coerce-block-tail-26978.stderr
+++ b/tests/ui/coercion/coerce-block-tail-26978.stderr
@@ -11,6 +11,6 @@ help: consider unboxing the value
 LL |     f(&{*x});
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coerce-block-tail-57749.stderr b/tests/ui/coercion/coerce-block-tail-57749.stderr
index 7e14f42eaaf..6a6f5ec11b9 100644
--- a/tests/ui/coercion/coerce-block-tail-57749.stderr
+++ b/tests/ui/coercion/coerce-block-tail-57749.stderr
@@ -9,6 +9,6 @@ help: consider dereferencing the type
 LL |     reset(&{ *Homura });
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coerce-block-tail-83783.stderr b/tests/ui/coercion/coerce-block-tail-83783.stderr
index da3c387773f..bf2c3899925 100644
--- a/tests/ui/coercion/coerce-block-tail-83783.stderr
+++ b/tests/ui/coercion/coerce-block-tail-83783.stderr
@@ -11,6 +11,6 @@ help: consider unboxing the value
 LL |     _consume_reference::<i32>(&*async { Box::new(7_i32) }.await);
    |                                +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coerce-block-tail-83850.stderr b/tests/ui/coercion/coerce-block-tail-83850.stderr
index 3cfebb8a543..e98b3e610a8 100644
--- a/tests/ui/coercion/coerce-block-tail-83850.stderr
+++ b/tests/ui/coercion/coerce-block-tail-83850.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn f(_: &[i32]) {}
    |    ^ ---------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coerce-block-tail.stderr b/tests/ui/coercion/coerce-block-tail.stderr
index 7044fc3cefc..1301f3b7813 100644
--- a/tests/ui/coercion/coerce-block-tail.stderr
+++ b/tests/ui/coercion/coerce-block-tail.stderr
@@ -11,6 +11,6 @@ help: consider unboxing the value
 LL |     let _: &i32 = & { *Box::new(1i32) };
    |                       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coerce-mut.stderr b/tests/ui/coercion/coerce-mut.stderr
index 11a4f310154..9bbfcc29e61 100644
--- a/tests/ui/coercion/coerce-mut.stderr
+++ b/tests/ui/coercion/coerce-mut.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn f(x: &mut i32) {}
    |    ^ -----------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coerce-reborrow-multi-arg-fail.stderr b/tests/ui/coercion/coerce-reborrow-multi-arg-fail.stderr
index 5cbdef21831..498ef33d52e 100644
--- a/tests/ui/coercion/coerce-reborrow-multi-arg-fail.stderr
+++ b/tests/ui/coercion/coerce-reborrow-multi-arg-fail.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn test<T>(_a: T, _b: T) {}
    |    ^^^^           -----
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/coercion-slice.stderr b/tests/ui/coercion/coercion-slice.stderr
index 17bbca7a0bd..26a7a5c1cdd 100644
--- a/tests/ui/coercion/coercion-slice.stderr
+++ b/tests/ui/coercion/coercion-slice.stderr
@@ -11,6 +11,6 @@ help: consider borrowing here
 LL |     let _: &[i32] = &[0];
    |                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coercion/issue-53475.stderr b/tests/ui/coercion/issue-53475.stderr
index 4778611bf1b..af114519add 100644
--- a/tests/ui/coercion/issue-53475.stderr
+++ b/tests/ui/coercion/issue-53475.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | impl<T: 'static> CoerceUnsized<Foo<dyn Any>> for Foo<T> {}
    |       +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/coercion/retslot-cast.stderr b/tests/ui/coercion/retslot-cast.stderr
index 798ce1199a9..dac21a7f25b 100644
--- a/tests/ui/coercion/retslot-cast.stderr
+++ b/tests/ui/coercion/retslot-cast.stderr
@@ -10,6 +10,6 @@ LL |     inner(x)
    = note: expected enum `Option<&dyn Iterator<Item = ()>>`
               found enum `Option<&dyn Iterator<Item = ()> + Send>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coherence/coherence-all-remote.stderr b/tests/ui/coherence/coherence-all-remote.stderr
index 7eca4175339..0cf9f87b40a 100644
--- a/tests/ui/coherence/coherence-all-remote.stderr
+++ b/tests/ui/coherence/coherence-all-remote.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote1<T> for isize { }
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/coherence-bigint-param.stderr b/tests/ui/coherence/coherence-bigint-param.stderr
index e8d74c917e4..e6c77624a8e 100644
--- a/tests/ui/coherence/coherence-bigint-param.stderr
+++ b/tests/ui/coherence/coherence-bigint-param.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote1<BigInt> for T { }
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type
    = note: in this case, 'before' refers to the following order: `impl<..> ForeignTrait<T1, ..., Tn> for T0`, where `T0` is the first and `Tn` is the last
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-implemented.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-implemented.stderr
index 9156972a1df..3618fe841b1 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-implemented.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-implemented.stderr
@@ -7,6 +7,6 @@ LL | impl<T:Even> MyTrait for T {
 LL | impl<T:Odd> MyTrait for T {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-unimplemented.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-unimplemented.stderr
index 8400968e122..510480f6a04 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-unimplemented.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-blanket-unimplemented.stderr
@@ -7,6 +7,6 @@ LL | impl<T:Even> MyTrait for T {
 LL | impl<T:Odd> MyTrait for T {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-cross-crate.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-cross-crate.stderr
index 4d7872598b1..4b86cffbe47 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-cross-crate.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-cross-crate.stderr
@@ -8,6 +8,6 @@ LL | impl GoMut for MyThingy {
            - impl<G> GoMut for G
              where G: Go;
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
index c2a925213da..ddb7474c289 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
@@ -7,6 +7,6 @@ LL | impl<T> MyTrait<T> for T {
 LL | impl MyTrait<MyType> for MyType {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyType`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr
index e1a5dffebda..b681285341b 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr
@@ -7,6 +7,6 @@ LL | impl<T:OtherTrait> MyTrait for T {
 LL | impl MyTrait for MyType {
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyType`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-specific.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-specific.stderr
index ba60a2ea929..164edff4a7b 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-specific.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-specific.stderr
@@ -7,6 +7,6 @@ LL | impl<T> MyTrait for T {
 LL | impl MyTrait for MyType {
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyType`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-cow.re_a.stderr b/tests/ui/coherence/coherence-cow.re_a.stderr
index fe4b5b41078..0bc017817b6 100644
--- a/tests/ui/coherence/coherence-cow.re_a.stderr
+++ b/tests/ui/coherence/coherence-cow.re_a.stderr
@@ -9,6 +9,6 @@ LL | impl<T> Remote for Pair<T,Cover<T>> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-cow.re_b.stderr b/tests/ui/coherence/coherence-cow.re_b.stderr
index da4ede3251e..9bdb49dcc04 100644
--- a/tests/ui/coherence/coherence-cow.re_b.stderr
+++ b/tests/ui/coherence/coherence-cow.re_b.stderr
@@ -9,6 +9,6 @@ LL | impl<T> Remote for Pair<Cover<T>,T> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-cow.re_c.stderr b/tests/ui/coherence/coherence-cow.re_c.stderr
index d1a20c0ca10..dfff2667ebb 100644
--- a/tests/ui/coherence/coherence-cow.re_c.stderr
+++ b/tests/ui/coherence/coherence-cow.re_c.stderr
@@ -9,6 +9,6 @@ LL | impl<T,U> Remote for Pair<Cover<T>,U> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-cross-crate-conflict.stderr b/tests/ui/coherence/coherence-cross-crate-conflict.stderr
index 3d253d56a45..812ce97721c 100644
--- a/tests/ui/coherence/coherence-cross-crate-conflict.stderr
+++ b/tests/ui/coherence/coherence-cross-crate-conflict.stderr
@@ -7,6 +7,6 @@ LL | impl<A> Foo for A {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/coherence-error-suppression.stderr b/tests/ui/coherence/coherence-error-suppression.stderr
index aadc80cb1c3..fcaa510c632 100644
--- a/tests/ui/coherence/coherence-error-suppression.stderr
+++ b/tests/ui/coherence/coherence-error-suppression.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `DoesNotExist` in this scope
 LL | impl Foo for DoesNotExist {}
    |              ^^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr b/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
index 7dabd97b94e..316da26b54d 100644
--- a/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
+++ b/tests/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
@@ -8,6 +8,6 @@ LL | impl<'a> Trait for fn(fn(&'a ())) {}
    |
    = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-fn-implied-bounds.stderr b/tests/ui/coherence/coherence-fn-implied-bounds.stderr
index 2018712043e..b0dea746709 100644
--- a/tests/ui/coherence/coherence-fn-implied-bounds.stderr
+++ b/tests/ui/coherence/coherence-fn-implied-bounds.stderr
@@ -16,5 +16,5 @@ note: the lint level is defined here
 LL | #![deny(coherence_leak_check)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-fn-inputs.stderr b/tests/ui/coherence/coherence-fn-inputs.stderr
index 82bd8a35f45..246ec5947b3 100644
--- a/tests/ui/coherence/coherence-fn-inputs.stderr
+++ b/tests/ui/coherence/coherence-fn-inputs.stderr
@@ -8,6 +8,6 @@ LL | impl Trait for for<'c> fn(&'c u32, &'c u32) {
    |
    = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-free-vs-bound-region.stderr b/tests/ui/coherence/coherence-free-vs-bound-region.stderr
index e2d84b83320..c97b32e429d 100644
--- a/tests/ui/coherence/coherence-free-vs-bound-region.stderr
+++ b/tests/ui/coherence/coherence-free-vs-bound-region.stderr
@@ -16,5 +16,5 @@ note: the lint level is defined here
 LL | #![deny(coherence_leak_check)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-fundamental-trait-objects.stderr b/tests/ui/coherence/coherence-fundamental-trait-objects.stderr
index a35a95ef4bf..db6a9474804 100644
--- a/tests/ui/coherence/coherence-fundamental-trait-objects.stderr
+++ b/tests/ui/coherence/coherence-fundamental-trait-objects.stderr
@@ -9,6 +9,6 @@ LL | impl Misc for dyn Fundamental<Local> {}
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr b/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr
index 684e528220f..9f813d6d571 100644
--- a/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr
+++ b/tests/ui/coherence/coherence-inherited-assoc-ty-cycle-err.stderr
@@ -22,6 +22,6 @@ LL | trait Trait<T> { type Assoc; }
    | ^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/coherence/coherence-inherited-subtyping.stderr b/tests/ui/coherence/coherence-inherited-subtyping.stderr
index f60b2aa2735..5c575393904 100644
--- a/tests/ui/coherence/coherence-inherited-subtyping.stderr
+++ b/tests/ui/coherence/coherence-inherited-subtyping.stderr
@@ -9,6 +9,6 @@ LL |     fn method1(&self) {}
    |
    = note: this behavior recently changed as a result of a bug fix; see rust-lang/rust#56105 for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/coherence/coherence-lone-type-parameter.stderr b/tests/ui/coherence/coherence-lone-type-parameter.stderr
index ef5b0883653..48d25bba8d7 100644
--- a/tests/ui/coherence/coherence-lone-type-parameter.stderr
+++ b/tests/ui/coherence/coherence-lone-type-parameter.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote for T { }
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/coherence-negative-impls-safe.stderr b/tests/ui/coherence/coherence-negative-impls-safe.stderr
index 1bd37f39590..759e50c3bea 100644
--- a/tests/ui/coherence/coherence-negative-impls-safe.stderr
+++ b/tests/ui/coherence/coherence-negative-impls-safe.stderr
@@ -7,6 +7,6 @@ LL | unsafe impl !Send for TestType {}
    | |           negative because of this
    | unsafe because of this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0198`.
diff --git a/tests/ui/coherence/coherence-negative-outlives-lifetimes.stock.stderr b/tests/ui/coherence/coherence-negative-outlives-lifetimes.stock.stderr
index 6d6e163b206..dbb22d8937d 100644
--- a/tests/ui/coherence/coherence-negative-outlives-lifetimes.stock.stderr
+++ b/tests/ui/coherence/coherence-negative-outlives-lifetimes.stock.stderr
@@ -6,6 +6,6 @@ LL | impl<'a, T: MyPredicate<'a>> MyTrait<'a> for T {}
 LL | impl<'a, T> MyTrait<'a> for &'a T {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-negative-outlives-lifetimes.with_negative_coherence.stderr b/tests/ui/coherence/coherence-negative-outlives-lifetimes.with_negative_coherence.stderr
index 6d6e163b206..dbb22d8937d 100644
--- a/tests/ui/coherence/coherence-negative-outlives-lifetimes.with_negative_coherence.stderr
+++ b/tests/ui/coherence/coherence-negative-outlives-lifetimes.with_negative_coherence.stderr
@@ -6,6 +6,6 @@ LL | impl<'a, T: MyPredicate<'a>> MyTrait<'a> for T {}
 LL | impl<'a, T> MyTrait<'a> for &'a T {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-no-direct-lifetime-dispatch.stderr b/tests/ui/coherence/coherence-no-direct-lifetime-dispatch.stderr
index 8a43ad7b7f0..ca8d7a5c4c3 100644
--- a/tests/ui/coherence/coherence-no-direct-lifetime-dispatch.stderr
+++ b/tests/ui/coherence/coherence-no-direct-lifetime-dispatch.stderr
@@ -6,6 +6,6 @@ LL | impl<T> MyTrait for T {}
 LL | impl<T: 'static> MyTrait for T {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlap-all-t-and-tuple.stderr b/tests/ui/coherence/coherence-overlap-all-t-and-tuple.stderr
index 6a0880334b6..a6e47d9f92e 100644
--- a/tests/ui/coherence/coherence-overlap-all-t-and-tuple.stderr
+++ b/tests/ui/coherence/coherence-overlap-all-t-and-tuple.stderr
@@ -7,6 +7,6 @@ LL | impl <T> From<T> for T {
 LL | impl <T11, U11> From<(U11,)> for (T11,) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(_,)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlap-issue-23516-inherent.next.stderr b/tests/ui/coherence/coherence-overlap-issue-23516-inherent.next.stderr
index c02a679c149..2f3ad627808 100644
--- a/tests/ui/coherence/coherence-overlap-issue-23516-inherent.next.stderr
+++ b/tests/ui/coherence/coherence-overlap-issue-23516-inherent.next.stderr
@@ -9,6 +9,6 @@ LL | impl<U:Sugar> Cake<Box<U>> { fn dummy(&self) { } }
    |
    = note: downstream crates may implement trait `Sugar` for type `std::boxed::Box<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/coherence/coherence-overlap-issue-23516-inherent.old.stderr b/tests/ui/coherence/coherence-overlap-issue-23516-inherent.old.stderr
index c02a679c149..2f3ad627808 100644
--- a/tests/ui/coherence/coherence-overlap-issue-23516-inherent.old.stderr
+++ b/tests/ui/coherence/coherence-overlap-issue-23516-inherent.old.stderr
@@ -9,6 +9,6 @@ LL | impl<U:Sugar> Cake<Box<U>> { fn dummy(&self) { } }
    |
    = note: downstream crates may implement trait `Sugar` for type `std::boxed::Box<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/coherence/coherence-overlap-issue-23516.next.stderr b/tests/ui/coherence/coherence-overlap-issue-23516.next.stderr
index a4e87af8ac4..b9494774025 100644
--- a/tests/ui/coherence/coherence-overlap-issue-23516.next.stderr
+++ b/tests/ui/coherence/coherence-overlap-issue-23516.next.stderr
@@ -8,6 +8,6 @@ LL | impl<U:Sugar> Sweet for Box<U> { }
    |
    = note: downstream crates may implement trait `Sugar` for type `std::boxed::Box<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlap-issue-23516.old.stderr b/tests/ui/coherence/coherence-overlap-issue-23516.old.stderr
index a4e87af8ac4..b9494774025 100644
--- a/tests/ui/coherence/coherence-overlap-issue-23516.old.stderr
+++ b/tests/ui/coherence/coherence-overlap-issue-23516.old.stderr
@@ -8,6 +8,6 @@ LL | impl<U:Sugar> Sweet for Box<U> { }
    |
    = note: downstream crates may implement trait `Sugar` for type `std::boxed::Box<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlap-negate-not-use-feature-gate.stderr b/tests/ui/coherence/coherence-overlap-negate-not-use-feature-gate.stderr
index 4b55001ecc0..21c82eedd5d 100644
--- a/tests/ui/coherence/coherence-overlap-negate-not-use-feature-gate.stderr
+++ b/tests/ui/coherence/coherence-overlap-negate-not-use-feature-gate.stderr
@@ -6,6 +6,6 @@ LL | impl<T: DerefMut> Foo for T {}
 LL | impl<U> Foo for &U {}
    | ^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlap-trait-alias.stderr b/tests/ui/coherence/coherence-overlap-trait-alias.stderr
index 687f3af0040..4f277ad68a6 100644
--- a/tests/ui/coherence/coherence-overlap-trait-alias.stderr
+++ b/tests/ui/coherence/coherence-overlap-trait-alias.stderr
@@ -6,6 +6,6 @@ LL | impl<T: AB> C for T {}
 LL | impl C for u32 {}
    | ^^^^^^^^^^^^^^ conflicting implementation for `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlap-upstream-inherent.stderr b/tests/ui/coherence/coherence-overlap-upstream-inherent.stderr
index f355c6e855c..65885ecac41 100644
--- a/tests/ui/coherence/coherence-overlap-upstream-inherent.stderr
+++ b/tests/ui/coherence/coherence-overlap-upstream-inherent.stderr
@@ -9,6 +9,6 @@ LL | impl A<i16> { fn dummy(&self) { } }
    |
    = note: upstream crates may add a new impl of trait `coherence_lib::Remote` for type `i16` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/coherence/coherence-overlap-upstream.stderr b/tests/ui/coherence/coherence-overlap-upstream.stderr
index 8272c887586..212ef484afc 100644
--- a/tests/ui/coherence/coherence-overlap-upstream.stderr
+++ b/tests/ui/coherence/coherence-overlap-upstream.stderr
@@ -8,6 +8,6 @@ LL | impl Foo for i16 {}
    |
    = note: upstream crates may add a new impl of trait `coherence_lib::Remote` for type `i16` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-overlapping-pairs.stderr b/tests/ui/coherence/coherence-overlapping-pairs.stderr
index 15c92dfeb07..4d0a9c6ee14 100644
--- a/tests/ui/coherence/coherence-overlapping-pairs.stderr
+++ b/tests/ui/coherence/coherence-overlapping-pairs.stderr
@@ -9,6 +9,6 @@ LL | impl<T> Remote for lib::Pair<T,Foo> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-pair-covered-uncovered-1.stderr b/tests/ui/coherence/coherence-pair-covered-uncovered-1.stderr
index 03d78712381..15cd66e9d09 100644
--- a/tests/ui/coherence/coherence-pair-covered-uncovered-1.stderr
+++ b/tests/ui/coherence/coherence-pair-covered-uncovered-1.stderr
@@ -10,6 +10,6 @@ LL | impl<T, U> Remote1<Pair<T, Local<U>>> for i32 { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-pair-covered-uncovered.stderr b/tests/ui/coherence/coherence-pair-covered-uncovered.stderr
index 73dfe2f572a..359dbe8509d 100644
--- a/tests/ui/coherence/coherence-pair-covered-uncovered.stderr
+++ b/tests/ui/coherence/coherence-pair-covered-uncovered.stderr
@@ -9,6 +9,6 @@ LL | impl<T,U> Remote for Pair<T,Local<U>> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-projection-conflict-orphan.stderr b/tests/ui/coherence/coherence-projection-conflict-orphan.stderr
index b1ee0795b2e..97601899305 100644
--- a/tests/ui/coherence/coherence-projection-conflict-orphan.stderr
+++ b/tests/ui/coherence/coherence-projection-conflict-orphan.stderr
@@ -9,6 +9,6 @@ LL | impl<A:Iterator> Foo<A::Item> for A { }
    |
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `i32` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-projection-conflict-ty-param.stderr b/tests/ui/coherence/coherence-projection-conflict-ty-param.stderr
index 94d242eaac4..f074467bbaa 100644
--- a/tests/ui/coherence/coherence-projection-conflict-ty-param.stderr
+++ b/tests/ui/coherence/coherence-projection-conflict-ty-param.stderr
@@ -7,6 +7,6 @@ LL |
 LL | impl<T, U> Foo<T> for Option<U> { }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Option<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-projection-conflict.stderr b/tests/ui/coherence/coherence-projection-conflict.stderr
index 7d2c584c370..c916091e62d 100644
--- a/tests/ui/coherence/coherence-projection-conflict.stderr
+++ b/tests/ui/coherence/coherence-projection-conflict.stderr
@@ -7,6 +7,6 @@ LL |
 LL | impl<A:Bar> Foo<A::Output> for A { }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-tuple-conflict.stderr b/tests/ui/coherence/coherence-tuple-conflict.stderr
index 09ad5e5b224..4e02c0eb43c 100644
--- a/tests/ui/coherence/coherence-tuple-conflict.stderr
+++ b/tests/ui/coherence/coherence-tuple-conflict.stderr
@@ -7,6 +7,6 @@ LL | impl<T> MyTrait for (T,T) {
 LL | impl<A,B> MyTrait for (A,B) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(_, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr b/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr
index a3a37fd2775..4f898ec127b 100644
--- a/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr
+++ b/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `takes_t`
 LL | fn takes_t<S: Trait>(s: S) {
    |               ^^^^^ required by this bound in `takes_t`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coherence/coherence-vec-local-2.stderr b/tests/ui/coherence/coherence-vec-local-2.stderr
index 95fdf172ec2..e4249710d00 100644
--- a/tests/ui/coherence/coherence-vec-local-2.stderr
+++ b/tests/ui/coherence/coherence-vec-local-2.stderr
@@ -9,6 +9,6 @@ LL | impl<T> Remote for Vec<Local<T>> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-vec-local.stderr b/tests/ui/coherence/coherence-vec-local.stderr
index 4835e771abd..c465fb1966e 100644
--- a/tests/ui/coherence/coherence-vec-local.stderr
+++ b/tests/ui/coherence/coherence-vec-local.stderr
@@ -9,6 +9,6 @@ LL | impl Remote for Vec<Local> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence-wasm-bindgen.stderr b/tests/ui/coherence/coherence-wasm-bindgen.stderr
index 600cd42d8c6..b3c3dac612d 100644
--- a/tests/ui/coherence/coherence-wasm-bindgen.stderr
+++ b/tests/ui/coherence/coherence-wasm-bindgen.stderr
@@ -23,5 +23,5 @@ note: the lint level is defined here
 LL | #![deny(coherence_leak_check)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-with-closure.stderr b/tests/ui/coherence/coherence-with-closure.stderr
index 431108e14d7..501279ffe6a 100644
--- a/tests/ui/coherence/coherence-with-closure.stderr
+++ b/tests/ui/coherence/coherence-with-closure.stderr
@@ -6,6 +6,6 @@ LL | impl Trait for Wrapper<OpaqueClosure> {}
 LL | impl<T: Sync> Trait for Wrapper<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Wrapper<OpaqueClosure>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-with-coroutine.stock.stderr b/tests/ui/coherence/coherence-with-coroutine.stock.stderr
index b2a9135c542..9cf20ea4936 100644
--- a/tests/ui/coherence/coherence-with-coroutine.stock.stderr
+++ b/tests/ui/coherence/coherence-with-coroutine.stock.stderr
@@ -6,6 +6,6 @@ LL | impl Trait for Wrapper<OpaqueCoroutine> {}
 LL | impl<T: Sync> Trait for Wrapper<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Wrapper<OpaqueCoroutine>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence_copy_like_err_fundamental_struct_tuple.stderr b/tests/ui/coherence/coherence_copy_like_err_fundamental_struct_tuple.stderr
index 93486fa5f36..50bbe12bc20 100644
--- a/tests/ui/coherence/coherence_copy_like_err_fundamental_struct_tuple.stderr
+++ b/tests/ui/coherence/coherence_copy_like_err_fundamental_struct_tuple.stderr
@@ -9,6 +9,6 @@ LL | impl MyTrait for lib::MyFundamentalStruct<(MyType,)> { }
    |
    = note: upstream crates may add a new impl of trait `lib::MyCopy` for type `lib::MyFundamentalStruct<(MyType,)>` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence_copy_like_err_struct.stderr b/tests/ui/coherence/coherence_copy_like_err_struct.stderr
index 7432733b932..715a825ceb0 100644
--- a/tests/ui/coherence/coherence_copy_like_err_struct.stderr
+++ b/tests/ui/coherence/coherence_copy_like_err_struct.stderr
@@ -9,6 +9,6 @@ LL | impl MyTrait for lib::MyStruct<MyType> { }
    |
    = note: upstream crates may add a new impl of trait `lib::MyCopy` for type `lib::MyStruct<MyType>` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence_copy_like_err_tuple.stderr b/tests/ui/coherence/coherence_copy_like_err_tuple.stderr
index 090497ec189..fbd293dba9a 100644
--- a/tests/ui/coherence/coherence_copy_like_err_tuple.stderr
+++ b/tests/ui/coherence/coherence_copy_like_err_tuple.stderr
@@ -9,6 +9,6 @@ LL | impl MyTrait for (MyType,) { }
    |
    = note: upstream crates may add a new impl of trait `lib::MyCopy` for type `(MyType,)` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence_inherent.stderr b/tests/ui/coherence/coherence_inherent.stderr
index b381b068073..da8c03847ed 100644
--- a/tests/ui/coherence/coherence_inherent.stderr
+++ b/tests/ui/coherence/coherence_inherent.stderr
@@ -10,6 +10,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL +     use Lib::TheTrait;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/coherence/coherence_inherent_cc.stderr b/tests/ui/coherence/coherence_inherent_cc.stderr
index 7b6cb7d4390..d34f6fa213b 100644
--- a/tests/ui/coherence/coherence_inherent_cc.stderr
+++ b/tests/ui/coherence/coherence_inherent_cc.stderr
@@ -10,6 +10,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL +     use coherence_inherent_cc_lib::TheTrait;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/coherence/coherence_local_err_struct.stderr b/tests/ui/coherence/coherence_local_err_struct.stderr
index afc6fc45d0e..96572b5a716 100644
--- a/tests/ui/coherence/coherence_local_err_struct.stderr
+++ b/tests/ui/coherence/coherence_local_err_struct.stderr
@@ -9,6 +9,6 @@ LL | impl lib::MyCopy for lib::MyStruct<MyType> { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/coherence_local_err_tuple.stderr b/tests/ui/coherence/coherence_local_err_tuple.stderr
index a4953859f77..85a063bb34a 100644
--- a/tests/ui/coherence/coherence_local_err_tuple.stderr
+++ b/tests/ui/coherence/coherence_local_err_tuple.stderr
@@ -9,6 +9,6 @@ LL | impl lib::MyCopy for (MyType,) { }
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/deep-bad-copy-reason.stderr b/tests/ui/coherence/deep-bad-copy-reason.stderr
index 7b6dd4b380f..e79abe35597 100644
--- a/tests/ui/coherence/deep-bad-copy-reason.stderr
+++ b/tests/ui/coherence/deep-bad-copy-reason.stderr
@@ -13,6 +13,6 @@ note: the `Copy` impl for `Interned<'tcx, ListS<T>>` requires that `OpaqueListCo
 LL | pub struct List<'tcx, T>(Interned<'tcx, ListS<T>>);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/coherence/illegal-copy-bad-projection.stderr b/tests/ui/coherence/illegal-copy-bad-projection.stderr
index 8fed9ba23b2..2a74cb5a9b8 100644
--- a/tests/ui/coherence/illegal-copy-bad-projection.stderr
+++ b/tests/ui/coherence/illegal-copy-bad-projection.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `void` in this scope
 LL |     type Ptr = *const void;
    |                       ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/coherence/impl-foreign-for-foreign.stderr b/tests/ui/coherence/impl-foreign-for-foreign.stderr
index 93f7a6fdc25..6c74b47a1c4 100644
--- a/tests/ui/coherence/impl-foreign-for-foreign.stderr
+++ b/tests/ui/coherence/impl-foreign-for-foreign.stderr
@@ -9,6 +9,6 @@ LL | impl Remote for i32 {
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/impl-foreign[foreign]-for-foreign.stderr b/tests/ui/coherence/impl-foreign[foreign]-for-foreign.stderr
index 65b3aa394a8..fe8a34b78cf 100644
--- a/tests/ui/coherence/impl-foreign[foreign]-for-foreign.stderr
+++ b/tests/ui/coherence/impl-foreign[foreign]-for-foreign.stderr
@@ -10,6 +10,6 @@ LL | impl Remote1<u32> for f64 {
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr b/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr
index 249a5c44c79..12d9a807f49 100644
--- a/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr
+++ b/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote for Box<T> {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr
index aed184767a0..6ca3ccd05fe 100644
--- a/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote1<u32> for T {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr
index d97e85dcb3c..1f3463e8837 100644
--- a/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote1<Local> for T {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type
    = note: in this case, 'before' refers to the following order: `impl<..> ForeignTrait<T1, ..., Tn> for T0`, where `T0` is the first and `Tn` is the last
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr b/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr
index 44e3b7eedb4..a1f3936497e 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote1<T> for u32 {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr
index ff72969dc52..acd84f7115f 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Remote1<T> for T {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/inter-crate-ambiguity-causes-notes.next.stderr b/tests/ui/coherence/inter-crate-ambiguity-causes-notes.next.stderr
index 9b2dbc66ca7..74be598c44c 100644
--- a/tests/ui/coherence/inter-crate-ambiguity-causes-notes.next.stderr
+++ b/tests/ui/coherence/inter-crate-ambiguity-causes-notes.next.stderr
@@ -12,6 +12,6 @@ LL | |     I: Iterator<Item = ()>,
    |
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `()` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/inter-crate-ambiguity-causes-notes.old.stderr b/tests/ui/coherence/inter-crate-ambiguity-causes-notes.old.stderr
index 9b2dbc66ca7..74be598c44c 100644
--- a/tests/ui/coherence/inter-crate-ambiguity-causes-notes.old.stderr
+++ b/tests/ui/coherence/inter-crate-ambiguity-causes-notes.old.stderr
@@ -12,6 +12,6 @@ LL | |     I: Iterator<Item = ()>,
    |
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `()` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/negative-coherence-check-placeholder-outlives.stderr b/tests/ui/coherence/negative-coherence-check-placeholder-outlives.stderr
index 52d36c92f99..f515c39ea8d 100644
--- a/tests/ui/coherence/negative-coherence-check-placeholder-outlives.stderr
+++ b/tests/ui/coherence/negative-coherence-check-placeholder-outlives.stderr
@@ -6,6 +6,6 @@ LL | impl<T> Bar for T where T: Foo {}
 LL | impl<T> Bar for Box<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Box<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/negative-coherence-considering-regions.any_lt.stderr b/tests/ui/coherence/negative-coherence-considering-regions.any_lt.stderr
index 442934a8949..f24de10f6ac 100644
--- a/tests/ui/coherence/negative-coherence-considering-regions.any_lt.stderr
+++ b/tests/ui/coherence/negative-coherence-considering-regions.any_lt.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Bar for T where T: Foo {}
 LL | impl<T> Bar for &T {}
    | ^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr b/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr
index 34f3904443c..5368db29338 100644
--- a/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr
+++ b/tests/ui/coherence/negative-coherence-placeholder-region-constraints-on-unification.explicit.stderr
@@ -15,5 +15,5 @@ note: the lint level is defined here
 LL | #![forbid(coherence_leak_check)]
    |           ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/strict-coherence-needs-negative-coherence.stderr b/tests/ui/coherence/strict-coherence-needs-negative-coherence.stderr
index b5472928778..82804e8baac 100644
--- a/tests/ui/coherence/strict-coherence-needs-negative-coherence.stderr
+++ b/tests/ui/coherence/strict-coherence-needs-negative-coherence.stderr
@@ -6,5 +6,5 @@ LL | #[rustc_strict_coherence]
 LL | trait Foo {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/warn-when-cycle-is-error-in-coherence.stderr b/tests/ui/coherence/warn-when-cycle-is-error-in-coherence.stderr
index 4f32639a631..4535b6f6811 100644
--- a/tests/ui/coherence/warn-when-cycle-is-error-in-coherence.stderr
+++ b/tests/ui/coherence/warn-when-cycle-is-error-in-coherence.stderr
@@ -22,7 +22,7 @@ note: the lint level is defined here
 LL | #![deny(coinductive_overlap_in_coherence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 Future incompatibility report: Future breakage diagnostic:
 error: implementations of `PartialEq<Interval<_>>` for `Interval<_>` will conflict in the future
diff --git a/tests/ui/command-line-diagnostics.stderr b/tests/ui/command-line-diagnostics.stderr
index 6223ad880d6..b719a00ad5d 100644
--- a/tests/ui/command-line-diagnostics.stderr
+++ b/tests/ui/command-line-diagnostics.stderr
@@ -9,6 +9,6 @@ LL |     let x = 42;
 LL |     x = 43;
    |     ^^^^^^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/command/need-crate-arg-ignore-tidy.x.stderr b/tests/ui/command/need-crate-arg-ignore-tidy.x.stderr
index 305f76694f7..89f7210c048 100644
--- a/tests/ui/command/need-crate-arg-ignore-tidy.x.stderr
+++ b/tests/ui/command/need-crate-arg-ignore-tidy.x.stderr
@@ -2,5 +2,5 @@ error: invalid character `'.'` in crate name: `need_crate_arg_ignore_tidy.x`
    |
    = help: you can either pass `--crate-name` on the command line or add `#![crate_name="…"]` to set the crate name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/compare-method/proj-outlives-region.stderr b/tests/ui/compare-method/proj-outlives-region.stderr
index 797a8167931..b349e24f589 100644
--- a/tests/ui/compare-method/proj-outlives-region.stderr
+++ b/tests/ui/compare-method/proj-outlives-region.stderr
@@ -7,6 +7,6 @@ LL |     fn foo() where T: 'a;
 LL |     fn foo() where U: 'a { }
    |                       ^^ impl has extra requirement `U: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/compare-method/region-extra-2.stderr b/tests/ui/compare-method/region-extra-2.stderr
index eb19d57ab05..3f55f673117 100644
--- a/tests/ui/compare-method/region-extra-2.stderr
+++ b/tests/ui/compare-method/region-extra-2.stderr
@@ -12,6 +12,6 @@ help: copy the `where` clause predicates from the trait
 LL |     fn renew<'b: 'a>(self) -> &'b mut [T] where 'b: 'a {
    |                                           ~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/compare-method/region-extra.stderr b/tests/ui/compare-method/region-extra.stderr
index 1a471e18d9d..065b3c152ed 100644
--- a/tests/ui/compare-method/region-extra.stderr
+++ b/tests/ui/compare-method/region-extra.stderr
@@ -13,6 +13,6 @@ LL -     fn foo() where 'a: 'b { }
 LL +     fn foo()  { }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/compare-method/region-unrelated.stderr b/tests/ui/compare-method/region-unrelated.stderr
index f7ae6f94438..75a4d51ce8f 100644
--- a/tests/ui/compare-method/region-unrelated.stderr
+++ b/tests/ui/compare-method/region-unrelated.stderr
@@ -7,6 +7,6 @@ LL |     fn foo() where T: 'a;
 LL |     fn foo() where V: 'a { }
    |                       ^^ impl has extra requirement `V: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/compare-method/reordered-type-param.stderr b/tests/ui/compare-method/reordered-type-param.stderr
index 1552d542d15..8a439acee13 100644
--- a/tests/ui/compare-method/reordered-type-param.stderr
+++ b/tests/ui/compare-method/reordered-type-param.stderr
@@ -19,6 +19,6 @@ LL |   fn b<C:Clone,D>(&self, x: C) -> C;
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/compare-method/trait-bound-on-type-parameter.stderr b/tests/ui/compare-method/trait-bound-on-type-parameter.stderr
index ce6885c1541..0899d5406f9 100644
--- a/tests/ui/compare-method/trait-bound-on-type-parameter.stderr
+++ b/tests/ui/compare-method/trait-bound-on-type-parameter.stderr
@@ -7,6 +7,6 @@ LL |   fn b<C,D>(&self, x: C) -> C;
 LL |     fn b<F: Sync, G>(&self, _x: F) -> F { panic!() }
    |             ^^^^ impl has extra requirement `F: Sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/compare-method/traits-misc-mismatch-2.stderr b/tests/ui/compare-method/traits-misc-mismatch-2.stderr
index 36bb764d40e..b8d3fd02ab5 100644
--- a/tests/ui/compare-method/traits-misc-mismatch-2.stderr
+++ b/tests/ui/compare-method/traits-misc-mismatch-2.stderr
@@ -7,6 +7,6 @@ LL |     fn zip<B, U: Iterator<U>>(self, other: U) -> ZipIterator<Self, U>;
 LL |     fn zip<B, U: Iterator<B>>(self, other: U) -> ZipIterator<T, U> {
    |                  ^^^^^^^^^^^ impl has extra requirement `U: Iterator<B>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/compile_error_macro.stderr b/tests/ui/compile_error_macro.stderr
index 91ebcaa6e9d..92d5564e8a7 100644
--- a/tests/ui/compile_error_macro.stderr
+++ b/tests/ui/compile_error_macro.stderr
@@ -4,5 +4,5 @@ error: a very descriptive error message
 LL |     compile_error!("a very descriptive error message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/conditional-compilation/cfg-attr-cfg-2.stderr b/tests/ui/conditional-compilation/cfg-attr-cfg-2.stderr
index d61872c48ea..5f7fea0965f 100644
--- a/tests/ui/conditional-compilation/cfg-attr-cfg-2.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-cfg-2.stderr
@@ -4,6 +4,6 @@ error[E0601]: `main` function not found in crate `cfg_attr_cfg_2`
 LL | fn main() { }
    |              ^ consider adding a `main` function to `$DIR/cfg-attr-cfg-2.rs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/conditional-compilation/cfg-attr-crate-2.stderr b/tests/ui/conditional-compilation/cfg-attr-crate-2.stderr
index 4997ca4db27..82dc4361999 100644
--- a/tests/ui/conditional-compilation/cfg-attr-crate-2.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-crate-2.stderr
@@ -7,6 +7,6 @@ LL | #![cfg_attr(broken, no_core)]
    = note: see issue #29639 <https://github.com/rust-lang/rust/issues/29639> for more information
    = help: add `#![feature(no_core)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/conditional-compilation/cfg-attr-invalid-predicate.stderr b/tests/ui/conditional-compilation/cfg-attr-invalid-predicate.stderr
index 96c571ebebd..2033894b3b4 100644
--- a/tests/ui/conditional-compilation/cfg-attr-invalid-predicate.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-invalid-predicate.stderr
@@ -4,6 +4,6 @@ error[E0537]: invalid predicate `foo`
 LL | #[cfg(foo(bar))]
    |       ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0537`.
diff --git a/tests/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr b/tests/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr
index c8762d15d94..daba4eb1a63 100644
--- a/tests/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-multi-invalid-1.stderr
@@ -7,6 +7,6 @@ LL | #![cfg_attr(broken, no_core, no_std)]
    = note: see issue #29639 <https://github.com/rust-lang/rust/issues/29639> for more information
    = help: add `#![feature(no_core)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr b/tests/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr
index e75b1c5b4c8..675792d2e32 100644
--- a/tests/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-multi-invalid-2.stderr
@@ -7,6 +7,6 @@ LL | #![cfg_attr(broken, no_std, no_core)]
    = note: see issue #29639 <https://github.com/rust-lang/rust/issues/29639> for more information
    = help: add `#![feature(no_core)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr b/tests/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr
index fc8df6552c3..c91ad128d6e 100644
--- a/tests/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-unknown-attribute-macro-expansion.stderr
@@ -9,5 +9,5 @@ LL | foo!();
    |
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/conditional-compilation/cfg-in-crate-1.stderr b/tests/ui/conditional-compilation/cfg-in-crate-1.stderr
index ff72c43efbd..98be6d01f1b 100644
--- a/tests/ui/conditional-compilation/cfg-in-crate-1.stderr
+++ b/tests/ui/conditional-compilation/cfg-in-crate-1.stderr
@@ -4,6 +4,6 @@ error[E0601]: `main` function not found in crate `cfg_in_crate_1`
 LL | #![cfg(bar)]
    |             ^ consider adding a `main` function to `$DIR/cfg-in-crate-1.rs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/conditional-compilation/cfg_accessible-stuck.stderr b/tests/ui/conditional-compilation/cfg_accessible-stuck.stderr
index 33af7d62548..22ed1c5a39e 100644
--- a/tests/ui/conditional-compilation/cfg_accessible-stuck.stderr
+++ b/tests/ui/conditional-compilation/cfg_accessible-stuck.stderr
@@ -4,5 +4,5 @@ error: cannot determine whether the path is accessible or not
 LL | #[cfg_accessible(S)]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/conditional-compilation/cfg_accessible-unstable.stderr b/tests/ui/conditional-compilation/cfg_accessible-unstable.stderr
index 2f55b9559c7..f0344190976 100644
--- a/tests/ui/conditional-compilation/cfg_accessible-unstable.stderr
+++ b/tests/ui/conditional-compilation/cfg_accessible-unstable.stderr
@@ -7,6 +7,6 @@ LL | #[cfg_accessible(std)]
    = note: see issue #64797 <https://github.com/rust-lang/rust/issues/64797> for more information
    = help: add `#![feature(cfg_accessible)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/conditional-compilation/test-cfg.stderr b/tests/ui/conditional-compilation/test-cfg.stderr
index c35fe2f9458..9715f16acc2 100644
--- a/tests/ui/conditional-compilation/test-cfg.stderr
+++ b/tests/ui/conditional-compilation/test-cfg.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `foo` in this scope
 LL |     foo();
    |     ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/confuse-field-and-method/issue-18343.stderr b/tests/ui/confuse-field-and-method/issue-18343.stderr
index 1c9a6847ceb..a51fd4f02aa 100644
--- a/tests/ui/confuse-field-and-method/issue-18343.stderr
+++ b/tests/ui/confuse-field-and-method/issue-18343.stderr
@@ -12,6 +12,6 @@ help: to call the function stored in `closure`, surround the field access with p
 LL |     (o.closure)();
    |     +         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/confuse-field-and-method/issue-32128.stderr b/tests/ui/confuse-field-and-method/issue-32128.stderr
index 4b96bce8d2e..3d860d8c85a 100644
--- a/tests/ui/confuse-field-and-method/issue-32128.stderr
+++ b/tests/ui/confuse-field-and-method/issue-32128.stderr
@@ -12,6 +12,6 @@ help: to call the function stored in `example`, surround the field access with p
 LL |     (demo.example)(1);
    |     +            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/confuse-field-and-method/private-field.stderr b/tests/ui/confuse-field-and-method/private-field.stderr
index 783378f8db5..142c8450427 100644
--- a/tests/ui/confuse-field-and-method/private-field.stderr
+++ b/tests/ui/confuse-field-and-method/private-field.stderr
@@ -7,6 +7,6 @@ LL |     pub struct Dog {
 LL |     let dog_age = dog.dog_age();
    |                       ^^^^^^^ private field, not a method
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/conservative_impl_trait.stderr b/tests/ui/conservative_impl_trait.stderr
index 63a4df242f8..eecdb6f9266 100644
--- a/tests/ui/conservative_impl_trait.stderr
+++ b/tests/ui/conservative_impl_trait.stderr
@@ -6,6 +6,6 @@ LL | fn will_ice(something: &u32) -> impl Iterator<Item = &u32> {
    |
    = help: the trait `Iterator` is not implemented for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr
index ef55242df87..1177965d0d2 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `check`
 LL | fn check<T: std::marker::ConstParamTy>() {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/associated-type-bound-fail.stderr b/tests/ui/const-generics/associated-type-bound-fail.stderr
index e5e7ee26e44..602a8927a85 100644
--- a/tests/ui/const-generics/associated-type-bound-fail.stderr
+++ b/tests/ui/const-generics/associated-type-bound-fail.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `Foo::Assoc`
 LL |     type Assoc: Bar<N>;
    |                 ^^^^^^ required by this bound in `Foo::Assoc`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/bad-generic-in-copy-impl.stderr b/tests/ui/const-generics/bad-generic-in-copy-impl.stderr
index 25701ce68cc..d60d8ec0e90 100644
--- a/tests/ui/const-generics/bad-generic-in-copy-impl.stderr
+++ b/tests/ui/const-generics/bad-generic-in-copy-impl.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     x: [u8; SIZE],
    |             ^^^^ expected `usize`, found `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/bad-subst-const-kind.stderr b/tests/ui/const-generics/bad-subst-const-kind.stderr
index bd24f9140e4..6f5bc567c37 100644
--- a/tests/ui/const-generics/bad-subst-const-kind.stderr
+++ b/tests/ui/const-generics/bad-subst-const-kind.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL | impl<const N: u64> Q for [u8; N] {
    |                               ^ expected `usize`, found `u64`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/const-arg-type-arg-misordered.stderr b/tests/ui/const-generics/const-arg-type-arg-misordered.stderr
index 4e12f7a8c6e..e91b885803e 100644
--- a/tests/ui/const-generics/const-arg-type-arg-misordered.stderr
+++ b/tests/ui/const-generics/const-arg-type-arg-misordered.stderr
@@ -4,6 +4,6 @@ error[E0747]: constant provided when a type was expected
 LL | fn foo<const N: usize>() -> Array<N, ()> {
    |                                   ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/const-generics/const-argument-non-static-lifetime.min.stderr b/tests/ui/const-generics/const-argument-non-static-lifetime.min.stderr
index 310ca75fdc9..52b7f2a37de 100644
--- a/tests/ui/const-generics/const-argument-non-static-lifetime.min.stderr
+++ b/tests/ui/const-generics/const-argument-non-static-lifetime.min.stderr
@@ -7,5 +7,5 @@ LL |         let _: &'a ();
    = note: lifetime parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/const-generic-default-wont-borrowck.stderr b/tests/ui/const-generics/const-generic-default-wont-borrowck.stderr
index a345c48b088..4cea35f1c8e 100644
--- a/tests/ui/const-generics/const-generic-default-wont-borrowck.stderr
+++ b/tests/ui/const-generics/const-generic-default-wont-borrowck.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let s: &'static str = todo!(); s.len()
    |                         +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/const-generics/const-param-before-other-params.stderr b/tests/ui/const-generics/const-param-before-other-params.stderr
index 2c7a47bbc78..8f8c87afe85 100644
--- a/tests/ui/const-generics/const-param-before-other-params.stderr
+++ b/tests/ui/const-generics/const-param-before-other-params.stderr
@@ -4,5 +4,5 @@ error: lifetime parameters must be declared prior to type and const parameters
 LL | fn bar<const X: u8, 'a>(_: &'a ()) {
    |       --------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const X: u8>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr b/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
index c5160d1c384..55bced29aff 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
@@ -6,6 +6,6 @@ LL | struct B<T, const N: T>(PhantomData<[T; N]>);
    |
    = note: type parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr b/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr
index e508890dd7c..2bfa604fc56 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr
@@ -6,6 +6,6 @@ LL | pub struct Dependent<T, const X: T>([(); X]);
    |
    = note: type parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr b/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr
index e508890dd7c..2bfa604fc56 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr
@@ -6,6 +6,6 @@ LL | pub struct Dependent<T, const X: T>([(); X]);
    |
    = note: type parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/const-param-with-additional-obligations.stderr b/tests/ui/const-generics/const-param-with-additional-obligations.stderr
index f7ec4d57401..a05554d7a36 100644
--- a/tests/ui/const-generics/const-param-with-additional-obligations.stderr
+++ b/tests/ui/const-generics/const-param-with-additional-obligations.stderr
@@ -6,6 +6,6 @@ LL | fn foo<const N: Foo<u8>>() {}
    |
    = note: `u8` must implement `Other`, but it does not
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/const-parameter-uppercase-lint.stderr b/tests/ui/const-generics/const-parameter-uppercase-lint.stderr
index efaa182852a..2a5ca5d39ce 100644
--- a/tests/ui/const-generics/const-parameter-uppercase-lint.stderr
+++ b/tests/ui/const-generics/const-parameter-uppercase-lint.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_upper_case_globals)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/defaults/default-on-impl.stderr b/tests/ui/const-generics/defaults/default-on-impl.stderr
index 4b2b0574253..691e0354edd 100644
--- a/tests/ui/const-generics/defaults/default-on-impl.stderr
+++ b/tests/ui/const-generics/defaults/default-on-impl.stderr
@@ -4,5 +4,5 @@ error: defaults for const parameters are only allowed in `struct`, `enum`, `type
 LL | impl<const N: usize = 1> Foo<N> {}
    |      ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/defaults/default-param-wf-concrete.next.stderr b/tests/ui/const-generics/defaults/default-param-wf-concrete.next.stderr
index 4259ce2b626..35aae462443 100644
--- a/tests/ui/const-generics/defaults/default-param-wf-concrete.next.stderr
+++ b/tests/ui/const-generics/defaults/default-param-wf-concrete.next.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | struct Foo<const N: u8 = { 255 + 1 }>;
    |                            ^^^^^^^ attempt to compute `u8::MAX + 1_u8`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/const-generics/defaults/default-param-wf-concrete.old.stderr b/tests/ui/const-generics/defaults/default-param-wf-concrete.old.stderr
index 4259ce2b626..35aae462443 100644
--- a/tests/ui/const-generics/defaults/default-param-wf-concrete.old.stderr
+++ b/tests/ui/const-generics/defaults/default-param-wf-concrete.old.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | struct Foo<const N: u8 = { 255 + 1 }>;
    |                            ^^^^^^^ attempt to compute `u8::MAX + 1_u8`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/const-generics/defaults/doesnt_infer.stderr b/tests/ui/const-generics/defaults/doesnt_infer.stderr
index a61411d6eb6..65ee0ecfdc5 100644
--- a/tests/ui/const-generics/defaults/doesnt_infer.stderr
+++ b/tests/ui/const-generics/defaults/doesnt_infer.stderr
@@ -9,6 +9,6 @@ help: consider giving `foo` an explicit type, where the value of const parameter
 LL |     let foo: Foo<N> = Foo::foo();
    |            ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/defaults/generic-expr-default-concrete.stderr b/tests/ui/const-generics/defaults/generic-expr-default-concrete.stderr
index 61b3551182c..fbf1adfb7a5 100644
--- a/tests/ui/const-generics/defaults/generic-expr-default-concrete.stderr
+++ b/tests/ui/const-generics/defaults/generic-expr-default-concrete.stderr
@@ -7,6 +7,6 @@ LL |     Foo::<10, 12>
    = note: expected constant `11`
               found constant `12`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/defaults/generic-expr-default-mismatched-types.stderr b/tests/ui/const-generics/defaults/generic-expr-default-mismatched-types.stderr
index e83f89a6033..25b3fed0daf 100644
--- a/tests/ui/const-generics/defaults/generic-expr-default-mismatched-types.stderr
+++ b/tests/ui/const-generics/defaults/generic-expr-default-mismatched-types.stderr
@@ -7,6 +7,6 @@ LL |     Foo::<N, { N + 2 }>
    = note: expected constant `{ N + 1 }`
               found constant `{ N + 2 }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/defaults/param-order-err-pretty-prints-default.stderr b/tests/ui/const-generics/defaults/param-order-err-pretty-prints-default.stderr
index ba08b4646d0..bf2b21c012d 100644
--- a/tests/ui/const-generics/defaults/param-order-err-pretty-prints-default.stderr
+++ b/tests/ui/const-generics/defaults/param-order-err-pretty-prints-default.stderr
@@ -4,5 +4,5 @@ error: lifetime parameters must be declared prior to type and const parameters
 LL | struct Foo<const M: usize = 10, 'a>(&'a u32);
    |           ----------------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const M: usize = 10>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/defaults/self-referential.stderr b/tests/ui/const-generics/defaults/self-referential.stderr
index 170c1f7f7b2..be67ea3f503 100644
--- a/tests/ui/const-generics/defaults/self-referential.stderr
+++ b/tests/ui/const-generics/defaults/self-referential.stderr
@@ -6,6 +6,6 @@ LL | trait Foo<const M: u8, const M: u8 = M> {}
    |                 |
    |                 first use of `M`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0403`.
diff --git a/tests/ui/const-generics/different_generic_args.full.stderr b/tests/ui/const-generics/different_generic_args.full.stderr
index eba1768f7dd..8a72b5aff6d 100644
--- a/tests/ui/const-generics/different_generic_args.full.stderr
+++ b/tests/ui/const-generics/different_generic_args.full.stderr
@@ -7,6 +7,6 @@ LL |     u = ConstUsize::<4> {};
    = note: expected struct `ConstUsize<3>`
               found struct `ConstUsize<4>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/different_generic_args.min.stderr b/tests/ui/const-generics/different_generic_args.min.stderr
index eba1768f7dd..8a72b5aff6d 100644
--- a/tests/ui/const-generics/different_generic_args.min.stderr
+++ b/tests/ui/const-generics/different_generic_args.min.stderr
@@ -7,6 +7,6 @@ LL |     u = ConstUsize::<4> {};
    = note: expected struct `ConstUsize<3>`
               found struct `ConstUsize<4>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/different_generic_args_array.stderr b/tests/ui/const-generics/different_generic_args_array.stderr
index 4c5b5ada4f1..e185474f5bd 100644
--- a/tests/ui/const-generics/different_generic_args_array.stderr
+++ b/tests/ui/const-generics/different_generic_args_array.stderr
@@ -7,6 +7,6 @@ LL |     x = Const::<{ [4] }> {};
    = note: expected struct `Const<[3]>`
               found struct `Const<[4]>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/dont-evaluate-array-len-on-err-1.stderr b/tests/ui/const-generics/dont-evaluate-array-len-on-err-1.stderr
index b3a27566026..4e9e001f2c1 100644
--- a/tests/ui/const-generics/dont-evaluate-array-len-on-err-1.stderr
+++ b/tests/ui/const-generics/dont-evaluate-array-len-on-err-1.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Foo {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/early/const-expression-parameter.stderr b/tests/ui/const-generics/early/const-expression-parameter.stderr
index 4ce1be25edb..ca4db8e28da 100644
--- a/tests/ui/const-generics/early/const-expression-parameter.stderr
+++ b/tests/ui/const-generics/early/const-expression-parameter.stderr
@@ -9,5 +9,5 @@ help: enclose the `const` expression in braces
 LL |     i32_identity::<{ 1 + 2 }>();
    |                    +       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/early/const-param-from-outer-fn.stderr b/tests/ui/const-generics/early/const-param-from-outer-fn.stderr
index 826f2657905..faba4ce10a1 100644
--- a/tests/ui/const-generics/early/const-param-from-outer-fn.stderr
+++ b/tests/ui/const-generics/early/const-param-from-outer-fn.stderr
@@ -8,6 +8,6 @@ LL |     fn bar() -> u32 {
 LL |         X
    |         ^ use of generic parameter from outer item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/const-generics/early/const-param-shadowing.stderr b/tests/ui/const-generics/early/const-param-shadowing.stderr
index 625338bd9b4..3ae2c9c8e60 100644
--- a/tests/ui/const-generics/early/const-param-shadowing.stderr
+++ b/tests/ui/const-generics/early/const-param-shadowing.stderr
@@ -9,6 +9,6 @@ help: if this generic argument was intended as a const parameter, surround it wi
 LL | fn test<const N: usize>() -> Foo<{ N }> {
    |                                  +   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/const-generics/ensure_is_evaluatable.stderr b/tests/ui/const-generics/ensure_is_evaluatable.stderr
index ab2871ff281..a6f36230820 100644
--- a/tests/ui/const-generics/ensure_is_evaluatable.stderr
+++ b/tests/ui/const-generics/ensure_is_evaluatable.stderr
@@ -14,5 +14,5 @@ LL | where
 LL |     [(); N + 1]:,
    |          ^^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/exhaustive-value.stderr b/tests/ui/const-generics/exhaustive-value.stderr
index deb65ddba70..42814c1fb70 100644
--- a/tests/ui/const-generics/exhaustive-value.stderr
+++ b/tests/ui/const-generics/exhaustive-value.stderr
@@ -15,6 +15,6 @@ LL |     <() as Foo<N>>::test()
              <() as Foo<7>>
            and 248 others
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/float-generic.adt_const_params.stderr b/tests/ui/const-generics/float-generic.adt_const_params.stderr
index 6fe5390471d..cae4806368a 100644
--- a/tests/ui/const-generics/float-generic.adt_const_params.stderr
+++ b/tests/ui/const-generics/float-generic.adt_const_params.stderr
@@ -4,6 +4,6 @@ error[E0741]: `f32` is forbidden as the type of a const generic parameter
 LL | fn foo<const F: f32>() {}
    |                 ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/float-generic.simple.stderr b/tests/ui/const-generics/float-generic.simple.stderr
index aeb19dc7532..eccf9059ee3 100644
--- a/tests/ui/const-generics/float-generic.simple.stderr
+++ b/tests/ui/const-generics/float-generic.simple.stderr
@@ -6,5 +6,5 @@ LL | fn foo<const F: f32>() {}
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/fn-const-param-infer.full.stderr b/tests/ui/const-generics/fn-const-param-infer.full.stderr
index 2d66a192332..48d4a45345a 100644
--- a/tests/ui/const-generics/fn-const-param-infer.full.stderr
+++ b/tests/ui/const-generics/fn-const-param-infer.full.stderr
@@ -4,6 +4,6 @@ error[E0741]: using function pointers as const generic parameters is forbidden
 LL | struct Checked<const F: fn(usize) -> bool>;
    |                         ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/fn-const-param-infer.min.stderr b/tests/ui/const-generics/fn-const-param-infer.min.stderr
index a7afa484275..f6d41809d67 100644
--- a/tests/ui/const-generics/fn-const-param-infer.min.stderr
+++ b/tests/ui/const-generics/fn-const-param-infer.min.stderr
@@ -6,5 +6,5 @@ LL | struct Checked<const F: fn(usize) -> bool>;
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/fn_with_two_const_inputs.stderr b/tests/ui/const-generics/fn_with_two_const_inputs.stderr
index c124010aab0..ad32a688c03 100644
--- a/tests/ui/const-generics/fn_with_two_const_inputs.stderr
+++ b/tests/ui/const-generics/fn_with_two_const_inputs.stderr
@@ -14,5 +14,5 @@ LL | where
 LL |     [(); N + 1]:,
    |          ^^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/forbid-non-structural_match-types.stderr b/tests/ui/const-generics/forbid-non-structural_match-types.stderr
index 0efb9e9d3c2..94afded9469 100644
--- a/tests/ui/const-generics/forbid-non-structural_match-types.stderr
+++ b/tests/ui/const-generics/forbid-non-structural_match-types.stderr
@@ -10,6 +10,6 @@ LL + #[derive(ConstParamTy, PartialEq, Eq)]
 LL | struct C;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/generic-param-mismatch.stderr b/tests/ui/const-generics/generic-param-mismatch.stderr
index d0776d49d71..be6b3b90ec7 100644
--- a/tests/ui/const-generics/generic-param-mismatch.stderr
+++ b/tests/ui/const-generics/generic-param-mismatch.stderr
@@ -9,6 +9,6 @@ LL |     [0; N]
    = note: expected array `[u8; M]`
               found array `[u8; N]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr b/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
index 0096d4ee23d..c42226b77f5 100644
--- a/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
+++ b/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
@@ -18,6 +18,6 @@ help: consider giving `y` an explicit type, where the type for type parameter `T
 LL |     let y: Mask<_, LANES> = Mask::<_, _>::splat(false);
    |          ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/const-generics/generic_const_exprs/abstract-consts-as-cast-5.stderr b/tests/ui/const-generics/generic_const_exprs/abstract-consts-as-cast-5.stderr
index d48b639dbde..4b76ae6cfd5 100644
--- a/tests/ui/const-generics/generic_const_exprs/abstract-consts-as-cast-5.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/abstract-consts-as-cast-5.stderr
@@ -6,5 +6,5 @@ LL |     bar::<{ N as usize as usize }>();
    |
    = help: try adding a `where` bound using this expression: `where [(); { N as usize as usize }]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr b/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
index e4a0cabe572..a8657bf5263 100644
--- a/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
@@ -6,5 +6,5 @@ LL |     bar::<{ T::ASSOC }>();
    |
    = help: try adding a `where` bound using this expression: `where [(); { T::ASSOC }]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/closures.stderr b/tests/ui/const-generics/generic_const_exprs/closures.stderr
index 45d7922bd0b..e245a6dab25 100644
--- a/tests/ui/const-generics/generic_const_exprs/closures.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/closures.stderr
@@ -22,6 +22,6 @@ LL | fn test<const N: usize>() -> [u8; N + (|| 42)()] {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
index f2625990840..a85e0cbcf7e 100644
--- a/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/const-block-is-poly.stderr
@@ -16,5 +16,5 @@ LL |     let _ = [0u8; const { std::mem::size_of::<T>() }];
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/const-generics/generic_const_exprs/eval-privacy.stderr b/tests/ui/const-generics/generic_const_exprs/eval-privacy.stderr
index 2d9de8805bb..043fa34d605 100644
--- a/tests/ui/const-generics/generic_const_exprs/eval-privacy.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/eval-privacy.stderr
@@ -7,6 +7,6 @@ LL |     type AssocTy = Const<{ my_const_fn(U) }>;
 LL | const fn my_const_fn(val: u8) -> u8 {
    | ----------------------------------- `fn(u8) -> u8 {my_const_fn}` declared as private
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0446`.
diff --git a/tests/ui/const-generics/generic_const_exprs/feature-gate-generic_const_exprs.stderr b/tests/ui/const-generics/generic_const_exprs/feature-gate-generic_const_exprs.stderr
index 2d60ebaa83a..3b456324819 100644
--- a/tests/ui/const-generics/generic_const_exprs/feature-gate-generic_const_exprs.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/feature-gate-generic_const_exprs.stderr
@@ -7,5 +7,5 @@ LL | type Arr<const N: usize> = [u8; N - 1];
    = help: const parameters may only be used as standalone arguments, i.e. `N`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/from-sig-fail.stderr b/tests/ui/const-generics/generic_const_exprs/from-sig-fail.stderr
index bd71b49ee23..080e920258d 100644
--- a/tests/ui/const-generics/generic_const_exprs/from-sig-fail.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/from-sig-fail.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of `test::<0>::{constant#0}` failed
 LL | fn test<const N: usize>() -> [u8; N - 1] {
    |                                   ^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr b/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr
index 827dd59d9ad..09b618fb3f0 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-105608.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     Combination::<0>.and::<_>().and::<_>();
    |                         ~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-72819-generic-in-const-eval.min.stderr b/tests/ui/const-generics/generic_const_exprs/issue-72819-generic-in-const-eval.min.stderr
index 42671412fa7..ef9ee6d7cfc 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-72819-generic-in-const-eval.min.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-72819-generic-in-const-eval.min.stderr
@@ -7,5 +7,5 @@ LL | where Assert::<{N < usize::MAX / 2}>: IsTrue,
    = help: const parameters may only be used as standalone arguments, i.e. `N`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-76595.stderr b/tests/ui/const-generics/generic_const_exprs/issue-76595.stderr
index 302da59651c..2cec51cce22 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-76595.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-76595.stderr
@@ -16,6 +16,6 @@ help: add missing generic argument
 LL |     test::<2, P>();
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-79518-default_trait_method_normalization.stderr b/tests/ui/const-generics/generic_const_exprs/issue-79518-default_trait_method_normalization.stderr
index 511ae58a1dc..08ecb2e4866 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-79518-default_trait_method_normalization.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-79518-default_trait_method_normalization.stderr
@@ -11,6 +11,6 @@ LL |         Self::AssocInstance == [(); std::mem::size_of::<Self::Assoc>()];
    = help: consider constraining the associated type `<Self as Foo>::Assoc` to `[(); std::mem::size_of::<Self::Assoc>()]` or calling a method that returns `<Self as Foo>::Assoc`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr b/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
index 9b66fc502b7..8d59235e2f4 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-80742.stderr
@@ -6,5 +6,5 @@ query stack during panic:
 #0 [eval_to_allocation_raw] const-evaluating + checking `<impl at $DIR/issue-80742.rs:26:1: 28:32>::{constant#0}`
 #1 [eval_to_valtree] evaluating type-level constant
 end of query stack
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-94287.stderr b/tests/ui/const-generics/generic_const_exprs/issue-94287.stderr
index dc7d0c54fcc..b57779739a5 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-94287.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-94287.stderr
@@ -11,5 +11,5 @@ help: consider enabling this feature
 LL + #![feature(generic_const_exprs)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr b/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr
index 8b6eb5b7594..1036b7261f2 100644
--- a/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/mismatched-gat-subst-kind.stderr
@@ -13,6 +13,6 @@ error[E0747]: constant provided when a type was expected
 LL | fn f<T: B<U<1i32> = ()>>() {}
    |             ^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/const-generics/generic_const_exprs/needs_where_clause.stderr b/tests/ui/const-generics/generic_const_exprs/needs_where_clause.stderr
index 7b41e39b7d7..395088bf2f2 100644
--- a/tests/ui/const-generics/generic_const_exprs/needs_where_clause.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/needs_where_clause.stderr
@@ -6,5 +6,5 @@ LL |   b: [f32; complex_maths::<T>(N)],
    |
    = help: try adding a `where` bound using this expression: `where [(); complex_maths::<T>(N)]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/no_where_clause.stderr b/tests/ui/const-generics/generic_const_exprs/no_where_clause.stderr
index 3e5c2f5cad1..100cf3f8b62 100644
--- a/tests/ui/const-generics/generic_const_exprs/no_where_clause.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/no_where_clause.stderr
@@ -6,5 +6,5 @@ LL |   b: [f32; complex_maths(N)],
    |
    = help: try adding a `where` bound using this expression: `where [(); complex_maths(N)]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/non_local_anon_const_diagnostics.stderr b/tests/ui/const-generics/generic_const_exprs/non_local_anon_const_diagnostics.stderr
index 3926c830adb..7d84d7bcae7 100644
--- a/tests/ui/const-generics/generic_const_exprs/non_local_anon_const_diagnostics.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/non_local_anon_const_diagnostics.stderr
@@ -7,6 +7,6 @@ LL |     let _: anon_const_non_local::Foo<2> = anon_const_non_local::foo::<M>();
    = note: expected constant `2`
               found constant `anon_const_non_local::::foo::{constant#0}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr b/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr
index b7ec657120c..272d3e74b9c 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/object-safety-err-ret.stderr
@@ -17,6 +17,6 @@ LL |     fn test(&self) -> [u8; bar::<Self>()];
    = help: consider moving `test` to another trait
    = help: only type `()` implements the trait, consider using it directly instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr b/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr
index 440cf457e19..9e480ce9b85 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/object-safety-err-where-bounds.stderr
@@ -20,5 +20,5 @@ note: the lint level is defined here
 LL | #![deny(where_clauses_object_safety)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr b/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
index 59e9fee1eaf..e800c5d059f 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
@@ -14,6 +14,6 @@ help: consider specifying the generic argument
 LL |     use_dyn::<N>(&());
    |            +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/generic_const_exprs/obligation-cause.stderr b/tests/ui/const-generics/generic_const_exprs/obligation-cause.stderr
index 63e6fcc8e11..eba8b9b6257 100644
--- a/tests/ui/const-generics/generic_const_exprs/obligation-cause.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/obligation-cause.stderr
@@ -15,6 +15,6 @@ LL | fn g<T>()
 LL |     Is<{ std::mem::size_of::<T>() == 0 }>: True,
    |                                            ^^^^ required by this bound in `g`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr b/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
index 0314d7ed23d..c73d1022ed3 100644
--- a/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
@@ -7,6 +7,6 @@ LL |     const ASSOC: usize;
 LL | impl<const N: u64> Q for [u8; N] {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `ASSOC` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr b/tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr
index 8cbd1265448..3bae93ccb83 100644
--- a/tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr
@@ -7,5 +7,5 @@ LL |         WHAT_A_TYPE => 0,
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/unresolved_lifetimes_error.stderr b/tests/ui/const-generics/generic_const_exprs/unresolved_lifetimes_error.stderr
index 976f037062d..67eed46eadd 100644
--- a/tests/ui/const-generics/generic_const_exprs/unresolved_lifetimes_error.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/unresolved_lifetimes_error.stderr
@@ -6,6 +6,6 @@ LL | fn foo() -> [(); {
 LL |     let a: &'a ();
    |             ^^ undeclared lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0261`.
diff --git a/tests/ui/const-generics/ice-68875.stderr b/tests/ui/const-generics/ice-68875.stderr
index 1db62c57fd4..5a39a572421 100644
--- a/tests/ui/const-generics/ice-68875.stderr
+++ b/tests/ui/const-generics/ice-68875.stderr
@@ -4,5 +4,5 @@ error: generic `Self` types are currently not permitted in anonymous constants
 LL |     data: &'a [u8; Self::SIZE],
    |                    ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/ice-const-generic-function-return-ty.stderr b/tests/ui/const-generics/ice-const-generic-function-return-ty.stderr
index a72f5800a07..5d3ef008b16 100644
--- a/tests/ui/const-generics/ice-const-generic-function-return-ty.stderr
+++ b/tests/ui/const-generics/ice-const-generic-function-return-ty.stderr
@@ -4,5 +4,5 @@ error: expected one of `(`, `::`, `<`, or `>`, found `;`
 LL | fn return_ty() -> impl Into<<() as Reexported;
    |                                              ^ expected one of `(`, `::`, `<`, or `>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/infer/cannot-infer-const-args.stderr b/tests/ui/const-generics/infer/cannot-infer-const-args.stderr
index 93e45a88a6c..e3caefef10f 100644
--- a/tests/ui/const-generics/infer/cannot-infer-const-args.stderr
+++ b/tests/ui/const-generics/infer/cannot-infer-const-args.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     foo::<X>();
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/infer/issue-77092.stderr b/tests/ui/const-generics/infer/issue-77092.stderr
index 1682b26ac87..5b411269862 100644
--- a/tests/ui/const-generics/infer/issue-77092.stderr
+++ b/tests/ui/const-generics/infer/issue-77092.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |         println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));
    |                                             ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/infer/method-chain.stderr b/tests/ui/const-generics/infer/method-chain.stderr
index f527ee6e4f5..2def9e85ab7 100644
--- a/tests/ui/const-generics/infer/method-chain.stderr
+++ b/tests/ui/const-generics/infer/method-chain.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     Foo.bar().bar().bar().bar().baz::<N>();
    |                                    +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/infer/one-param-uninferred.stderr b/tests/ui/const-generics/infer/one-param-uninferred.stderr
index cf70c218139..3e33fec9cef 100644
--- a/tests/ui/const-generics/infer/one-param-uninferred.stderr
+++ b/tests/ui/const-generics/infer/one-param-uninferred.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |     let _: [u8; 17] = foo::<17, M>();
    |                          +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/infer/uninferred-consts.stderr b/tests/ui/const-generics/infer/uninferred-consts.stderr
index 20daf45706b..0ec6ac9c22e 100644
--- a/tests/ui/const-generics/infer/uninferred-consts.stderr
+++ b/tests/ui/const-generics/infer/uninferred-consts.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |     Foo.foo::<A, B>();
    |            ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/const-generics/invalid-constant-in-args.stderr b/tests/ui/const-generics/invalid-constant-in-args.stderr
index 2545cc6f396..158b9722ee6 100644
--- a/tests/ui/const-generics/invalid-constant-in-args.stderr
+++ b/tests/ui/const-generics/invalid-constant-in-args.stderr
@@ -6,6 +6,6 @@ LL |     let _: Cell<&str, "a"> = Cell::new("");
    |            |
    |            expected 1 generic argument
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/const-generics/invariant.stderr b/tests/ui/const-generics/invariant.stderr
index aabe4c93b36..f631e131146 100644
--- a/tests/ui/const-generics/invariant.stderr
+++ b/tests/ui/const-generics/invariant.stderr
@@ -21,6 +21,6 @@ LL |     v
    = note: expected reference `&Foo<fn(&())>`
               found reference `&Foo<for<'a> fn(&'a ())>`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/issue-112505-overflow.stderr b/tests/ui/const-generics/issue-112505-overflow.stderr
index bd8a4feeff5..0bd3f6eddd4 100644
--- a/tests/ui/const-generics/issue-112505-overflow.stderr
+++ b/tests/ui/const-generics/issue-112505-overflow.stderr
@@ -7,6 +7,6 @@ LL |     unsafe { std::mem::transmute(v) }
    = note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[u32; 8888888]; 9999999]` are too big for the current architecture)
    = note: target type: `[[[u32; 9999999]; 777777777]; 239]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/const-generics/issue-66451.stderr b/tests/ui/const-generics/issue-66451.stderr
index 946d5148667..404e3839bca 100644
--- a/tests/ui/const-generics/issue-66451.stderr
+++ b/tests/ui/const-generics/issue-66451.stderr
@@ -15,6 +15,6 @@ LL | |     }> = x;
    = note: expected struct `Test<Foo { value: 3, nested: &Bar::<i32>(5) }>`
               found struct `Test<Foo { value: 3, nested: &Bar::<i32>(4) }>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/issue-80471.stderr b/tests/ui/const-generics/issue-80471.stderr
index 3b7143de543..b21ad3aec79 100644
--- a/tests/ui/const-generics/issue-80471.stderr
+++ b/tests/ui/const-generics/issue-80471.stderr
@@ -19,6 +19,6 @@ LL + #[derive(ConstParamTy)]
 LL | enum Nat {
    |
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/issue-93647.stderr b/tests/ui/const-generics/issue-93647.stderr
index 18370eea571..a87b59940cb 100644
--- a/tests/ui/const-generics/issue-93647.stderr
+++ b/tests/ui/const-generics/issue-93647.stderr
@@ -8,6 +8,6 @@ LL |     (||1usize)()
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/const-generics/issues/issue-56445-1.full.stderr b/tests/ui/const-generics/issues/issue-56445-1.full.stderr
index 5fc0ec26047..86eb57355bd 100644
--- a/tests/ui/const-generics/issues/issue-56445-1.full.stderr
+++ b/tests/ui/const-generics/issues/issue-56445-1.full.stderr
@@ -6,6 +6,6 @@ LL | struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);
    |
    = note: lifetime parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/issues/issue-56445-2.stderr b/tests/ui/const-generics/issues/issue-56445-2.stderr
index 770c80cbbd3..351dcb1a155 100644
--- a/tests/ui/const-generics/issues/issue-56445-2.stderr
+++ b/tests/ui/const-generics/issues/issue-56445-2.stderr
@@ -10,5 +10,5 @@ note: not a concrete type
 LL | impl<'a> OnDiskDirEntry<'a> {
    |          ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-56445-3.stderr b/tests/ui/const-generics/issues/issue-56445-3.stderr
index f1c49eecfb5..96b68ca22f4 100644
--- a/tests/ui/const-generics/issues/issue-56445-3.stderr
+++ b/tests/ui/const-generics/issues/issue-56445-3.stderr
@@ -4,5 +4,5 @@ error: generic `Self` types are currently not permitted in anonymous constants
 LL |     ram: [u8; Self::SIZE],
    |               ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-61336-2.stderr b/tests/ui/const-generics/issues/issue-61336-2.stderr
index 5bb35669623..0af6f87a68d 100644
--- a/tests/ui/const-generics/issues/issue-61336-2.stderr
+++ b/tests/ui/const-generics/issues/issue-61336-2.stderr
@@ -10,6 +10,6 @@ help: consider restricting type parameter `T`
 LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/issues/issue-61336.stderr b/tests/ui/const-generics/issues/issue-61336.stderr
index 8d9e545b456..4132e511240 100644
--- a/tests/ui/const-generics/issues/issue-61336.stderr
+++ b/tests/ui/const-generics/issues/issue-61336.stderr
@@ -10,6 +10,6 @@ help: consider restricting type parameter `T`
 LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/issues/issue-62878.full.stderr b/tests/ui/const-generics/issues/issue-62878.full.stderr
index c658b5a6e68..615bfeb65a5 100644
--- a/tests/ui/const-generics/issues/issue-62878.full.stderr
+++ b/tests/ui/const-generics/issues/issue-62878.full.stderr
@@ -6,6 +6,6 @@ LL | fn foo<const N: usize, const A: [u8; N]>() {}
    |
    = note: const parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr b/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
index e2d8c5ca0e1..5082705927e 100644
--- a/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
+++ b/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
@@ -6,6 +6,6 @@ LL | fn test<const T: &'static dyn A>() {
    |
    = note: `(dyn A + 'static)` must implement `ConstParamTy`, but it does not
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/issues/issue-63322-forbid-dyn.min.stderr b/tests/ui/const-generics/issues/issue-63322-forbid-dyn.min.stderr
index 9d80f1cd01b..b9588e23e55 100644
--- a/tests/ui/const-generics/issues/issue-63322-forbid-dyn.min.stderr
+++ b/tests/ui/const-generics/issues/issue-63322-forbid-dyn.min.stderr
@@ -7,5 +7,5 @@ LL | fn test<const T: &'static dyn A>() {
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67375.full.stderr b/tests/ui/const-generics/issues/issue-67375.full.stderr
index 13cb8d1cd68..96e0f1b0e1f 100644
--- a/tests/ui/const-generics/issues/issue-67375.full.stderr
+++ b/tests/ui/const-generics/issues/issue-67375.full.stderr
@@ -8,5 +8,5 @@ LL |     inner: [(); { [|_: &T| {}; 0].len() }],
    |
    = help: consider moving this anonymous constant into a `const` function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67739.full.stderr b/tests/ui/const-generics/issues/issue-67739.full.stderr
index f1a426c3c58..bdf05023d5f 100644
--- a/tests/ui/const-generics/issues/issue-67739.full.stderr
+++ b/tests/ui/const-generics/issues/issue-67739.full.stderr
@@ -6,5 +6,5 @@ LL |         [0u8; mem::size_of::<Self::Associated>()];
    |
    = help: try adding a `where` bound using this expression: `where [(); mem::size_of::<Self::Associated>()]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67739.min.stderr b/tests/ui/const-generics/issues/issue-67739.min.stderr
index dcbe5b94a62..14037b9eea5 100644
--- a/tests/ui/const-generics/issues/issue-67739.min.stderr
+++ b/tests/ui/const-generics/issues/issue-67739.min.stderr
@@ -6,5 +6,5 @@ LL |         [0u8; mem::size_of::<Self::Associated>()];
    |
    = note: this may fail depending on what value the parameter takes
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67945-1.full.stderr b/tests/ui/const-generics/issues/issue-67945-1.full.stderr
index ee17ec3c698..2ecdc0366d5 100644
--- a/tests/ui/const-generics/issues/issue-67945-1.full.stderr
+++ b/tests/ui/const-generics/issues/issue-67945-1.full.stderr
@@ -12,6 +12,6 @@ LL |         let x: S = MaybeUninit::uninit();
    = note: expected type parameter `S`
                        found union `MaybeUninit<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/issues/issue-67945-2.full.stderr b/tests/ui/const-generics/issues/issue-67945-2.full.stderr
index 47429b7612f..837927d588c 100644
--- a/tests/ui/const-generics/issues/issue-67945-2.full.stderr
+++ b/tests/ui/const-generics/issues/issue-67945-2.full.stderr
@@ -13,5 +13,5 @@ LL | |     }],
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67945-2.min.stderr b/tests/ui/const-generics/issues/issue-67945-2.min.stderr
index 6e07af1e672..62fbed71aef 100644
--- a/tests/ui/const-generics/issues/issue-67945-2.min.stderr
+++ b/tests/ui/const-generics/issues/issue-67945-2.min.stderr
@@ -4,5 +4,5 @@ error: generic `Self` types are currently not permitted in anonymous constants
 LL |         let x: Option<Box<Self>> = None;
    |                           ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67945-3.full.stderr b/tests/ui/const-generics/issues/issue-67945-3.full.stderr
index 98f9f83976a..9683769aa24 100644
--- a/tests/ui/const-generics/issues/issue-67945-3.full.stderr
+++ b/tests/ui/const-generics/issues/issue-67945-3.full.stderr
@@ -12,5 +12,5 @@ LL | |     }],
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-67945-4.full.stderr b/tests/ui/const-generics/issues/issue-67945-4.full.stderr
index c03d40a7bb8..5450cabef61 100644
--- a/tests/ui/const-generics/issues/issue-67945-4.full.stderr
+++ b/tests/ui/const-generics/issues/issue-67945-4.full.stderr
@@ -12,5 +12,5 @@ LL | |     }],
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-68615-adt.min.stderr b/tests/ui/const-generics/issues/issue-68615-adt.min.stderr
index c8b9f17196a..20962098bff 100644
--- a/tests/ui/const-generics/issues/issue-68615-adt.min.stderr
+++ b/tests/ui/const-generics/issues/issue-68615-adt.min.stderr
@@ -7,5 +7,5 @@ LL | struct Const<const V: [usize; 0]> {}
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-68615-array.min.stderr b/tests/ui/const-generics/issues/issue-68615-array.min.stderr
index fc6cef9d44e..8c76f9b5d65 100644
--- a/tests/ui/const-generics/issues/issue-68615-array.min.stderr
+++ b/tests/ui/const-generics/issues/issue-68615-array.min.stderr
@@ -7,5 +7,5 @@ LL | struct Foo<const V: [usize; 0] > {}
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-71169.full.stderr b/tests/ui/const-generics/issues/issue-71169.full.stderr
index ccdfbbd54cf..9553be6fc07 100644
--- a/tests/ui/const-generics/issues/issue-71169.full.stderr
+++ b/tests/ui/const-generics/issues/issue-71169.full.stderr
@@ -6,6 +6,6 @@ LL | fn foo<const LEN: usize, const DATA: [u8; LEN]>() {}
    |
    = note: const parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/issues/issue-71202.stderr b/tests/ui/const-generics/issues/issue-71202.stderr
index 27754061086..2aa9e344067 100644
--- a/tests/ui/const-generics/issues/issue-71202.stderr
+++ b/tests/ui/const-generics/issues/issue-71202.stderr
@@ -29,5 +29,5 @@ LL | |     } as usize] = [];
                    <IsCopy<T>>::VALUE
                } as usize]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-71382.full.stderr b/tests/ui/const-generics/issues/issue-71382.full.stderr
index ab2a4e64a83..95faa406f85 100644
--- a/tests/ui/const-generics/issues/issue-71382.full.stderr
+++ b/tests/ui/const-generics/issues/issue-71382.full.stderr
@@ -4,6 +4,6 @@ error[E0741]: using function pointers as const generic parameters is forbidden
 LL |     fn test<const FN: fn()>(&self) {
    |                       ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/issues/issue-71382.min.stderr b/tests/ui/const-generics/issues/issue-71382.min.stderr
index 217166d8479..0c58b10c0b7 100644
--- a/tests/ui/const-generics/issues/issue-71382.min.stderr
+++ b/tests/ui/const-generics/issues/issue-71382.min.stderr
@@ -6,5 +6,5 @@ LL |     fn test<const FN: fn()>(&self) {
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-71611.full.stderr b/tests/ui/const-generics/issues/issue-71611.full.stderr
index b55f410a023..6f6a9fc21a6 100644
--- a/tests/ui/const-generics/issues/issue-71611.full.stderr
+++ b/tests/ui/const-generics/issues/issue-71611.full.stderr
@@ -6,6 +6,6 @@ LL | fn func<A, const F: fn(inner: A)>(outer: A) {
    |
    = note: type parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/issues/issue-72352.full.stderr b/tests/ui/const-generics/issues/issue-72352.full.stderr
index 92580b33685..cc46e7951f0 100644
--- a/tests/ui/const-generics/issues/issue-72352.full.stderr
+++ b/tests/ui/const-generics/issues/issue-72352.full.stderr
@@ -4,6 +4,6 @@ error[E0741]: using function pointers as const generic parameters is forbidden
 LL | unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize {
    |                                          ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/issues/issue-72352.min.stderr b/tests/ui/const-generics/issues/issue-72352.min.stderr
index b010996b896..cd009c973ae 100644
--- a/tests/ui/const-generics/issues/issue-72352.min.stderr
+++ b/tests/ui/const-generics/issues/issue-72352.min.stderr
@@ -6,5 +6,5 @@ LL | unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-72845.stderr b/tests/ui/const-generics/issues/issue-72845.stderr
index 631c8605fb4..9ab18c3a53d 100644
--- a/tests/ui/const-generics/issues/issue-72845.stderr
+++ b/tests/ui/const-generics/issues/issue-72845.stderr
@@ -7,6 +7,6 @@ LL | impl<T: Spec1> Foo for T {
 LL | impl<T: Spec2> Foo for T {
    | ^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/const-generics/issues/issue-73491.min.stderr b/tests/ui/const-generics/issues/issue-73491.min.stderr
index fdf057bdbe4..64df76756ac 100644
--- a/tests/ui/const-generics/issues/issue-73491.min.stderr
+++ b/tests/ui/const-generics/issues/issue-73491.min.stderr
@@ -7,5 +7,5 @@ LL | fn hoge<const IN: [u32; LEN]>() {}
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-73727-static-reference-array-const-param.min.stderr b/tests/ui/const-generics/issues/issue-73727-static-reference-array-const-param.min.stderr
index bed0a02a726..2b33f35defd 100644
--- a/tests/ui/const-generics/issues/issue-73727-static-reference-array-const-param.min.stderr
+++ b/tests/ui/const-generics/issues/issue-73727-static-reference-array-const-param.min.stderr
@@ -7,5 +7,5 @@ LL | fn a<const X: &'static [u32]>() {}
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-74255.min.stderr b/tests/ui/const-generics/issues/issue-74255.min.stderr
index affeca167e9..63d8fc12fa4 100644
--- a/tests/ui/const-generics/issues/issue-74255.min.stderr
+++ b/tests/ui/const-generics/issues/issue-74255.min.stderr
@@ -7,5 +7,5 @@ LL |     fn ice_struct_fn<const I: IceEnum>() {}
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-75047.min.stderr b/tests/ui/const-generics/issues/issue-75047.min.stderr
index e316b4624a0..1d7ac1b0111 100644
--- a/tests/ui/const-generics/issues/issue-75047.min.stderr
+++ b/tests/ui/const-generics/issues/issue-75047.min.stderr
@@ -7,5 +7,5 @@ LL | struct Foo<const N: [u8; Bar::<u32>::value()]>;
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-79674.stderr b/tests/ui/const-generics/issues/issue-79674.stderr
index ba7fd2ca3cc..1e7878e8da9 100644
--- a/tests/ui/const-generics/issues/issue-79674.stderr
+++ b/tests/ui/const-generics/issues/issue-79674.stderr
@@ -15,6 +15,6 @@ LL |     A: MiniTypeId, B: MiniTypeId,
 LL |     Lift<{is_same_type::<A, B>()}>: IsFalse {}
    |                                     ^^^^^^^ required by this bound in `requires_distinct`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/issues/issue-80062.stderr b/tests/ui/const-generics/issues/issue-80062.stderr
index 754f18d5cc4..5f53dca4bed 100644
--- a/tests/ui/const-generics/issues/issue-80062.stderr
+++ b/tests/ui/const-generics/issues/issue-80062.stderr
@@ -7,5 +7,5 @@ LL |     let _: [u8; sof::<T>()];
    = note: type parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-80375.stderr b/tests/ui/const-generics/issues/issue-80375.stderr
index 5409002a9fd..6abbf1c0f75 100644
--- a/tests/ui/const-generics/issues/issue-80375.stderr
+++ b/tests/ui/const-generics/issues/issue-80375.stderr
@@ -7,5 +7,5 @@ LL | struct MyArray<const COUNT: usize>([u8; COUNT + 1]);
    = help: const parameters may only be used as standalone arguments, i.e. `COUNT`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-82956.stderr b/tests/ui/const-generics/issues/issue-82956.stderr
index d70c8d0bfbf..d0fc7112426 100644
--- a/tests/ui/const-generics/issues/issue-82956.stderr
+++ b/tests/ui/const-generics/issues/issue-82956.stderr
@@ -16,6 +16,6 @@ LL + use std::collections::btree_set::IntoIter;
    |
      and 8 other candidates
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/const-generics/issues/issue-83249.stderr b/tests/ui/const-generics/issues/issue-83249.stderr
index 5187434ff40..f41115ce427 100644
--- a/tests/ui/const-generics/issues/issue-83249.stderr
+++ b/tests/ui/const-generics/issues/issue-83249.stderr
@@ -18,6 +18,6 @@ help: consider giving this pattern a type
 LL |     let _: /* Type */ = foo([0; 1]);
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/const-generics/issues/issue-83466.stderr b/tests/ui/const-generics/issues/issue-83466.stderr
index bcfd7063989..91451a799b0 100644
--- a/tests/ui/const-generics/issues/issue-83466.stderr
+++ b/tests/ui/const-generics/issues/issue-83466.stderr
@@ -17,6 +17,6 @@ error[E0747]: constant provided when a type was expected
 LL |     S.func::<'a, 10_u32>()
    |                  ^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/const-generics/issues/issue-83765.stderr b/tests/ui/const-generics/issues/issue-83765.stderr
index df734933c25..d9956875cf8 100644
--- a/tests/ui/const-generics/issues/issue-83765.stderr
+++ b/tests/ui/const-generics/issues/issue-83765.stderr
@@ -17,6 +17,6 @@ LL | trait TensorDimension {
    | ^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/const-generics/issues/issue-84659.stderr b/tests/ui/const-generics/issues/issue-84659.stderr
index 2dfc48a34e4..796c5515e04 100644
--- a/tests/ui/const-generics/issues/issue-84659.stderr
+++ b/tests/ui/const-generics/issues/issue-84659.stderr
@@ -6,5 +6,5 @@ LL |     type Baz: Bar<{ Self::N }>;
    |
    = help: try adding a `where` bound using this expression: `where [(); { Self::N }]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-86530.stderr b/tests/ui/const-generics/issues/issue-86530.stderr
index d02808f7c56..aa8aa4e10a8 100644
--- a/tests/ui/const-generics/issues/issue-86530.stderr
+++ b/tests/ui/const-generics/issues/issue-86530.stderr
@@ -20,6 +20,6 @@ LL | where
 LL |     T: X,
    |        ^ required by this bound in `z`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/issues/issue-86820.stderr b/tests/ui/const-generics/issues/issue-86820.stderr
index 3a9cd957f35..2928c1923b8 100644
--- a/tests/ui/const-generics/issues/issue-86820.stderr
+++ b/tests/ui/const-generics/issues/issue-86820.stderr
@@ -11,6 +11,6 @@ LL | impl Bits for u8 {
 LL |     fn bit<const I: usize>(self) -> bool {
    |            ^^^^^^^^^^^^^^ found const parameter of type `usize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/const-generics/issues/issue-90364.stderr b/tests/ui/const-generics/issues/issue-90364.stderr
index 23424d7b919..6c00a654cde 100644
--- a/tests/ui/const-generics/issues/issue-90364.stderr
+++ b/tests/ui/const-generics/issues/issue-90364.stderr
@@ -6,6 +6,6 @@ LL | pub struct Foo<T, const H: T>(T)
    |
    = note: type parameters may not be used in the type of const parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/issues/issue-90455.stderr b/tests/ui/const-generics/issues/issue-90455.stderr
index 724d7f42e69..1db90609572 100644
--- a/tests/ui/const-generics/issues/issue-90455.stderr
+++ b/tests/ui/const-generics/issues/issue-90455.stderr
@@ -6,5 +6,5 @@ LL |     n: [u64; num_limbs(N)],
    |
    = help: try adding a `where` bound using this expression: `where [(); num_limbs(N)]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-97278.stderr b/tests/ui/const-generics/issues/issue-97278.stderr
index 31e92f840e1..47e6bf1df4d 100644
--- a/tests/ui/const-generics/issues/issue-97278.stderr
+++ b/tests/ui/const-generics/issues/issue-97278.stderr
@@ -10,6 +10,6 @@ LL + #[derive(ConstParamTy)]
 LL | enum Bar {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/issues/issue-98629.stderr b/tests/ui/const-generics/issues/issue-98629.stderr
index 4a248be76a9..e7582aaae11 100644
--- a/tests/ui/const-generics/issues/issue-98629.stderr
+++ b/tests/ui/const-generics/issues/issue-98629.stderr
@@ -7,6 +7,6 @@ LL |     const N: usize;
 LL | impl const Trait for i32 {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^ missing `N` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/const-generics/late-bound-vars/late-bound-in-return-issue-77357.stderr b/tests/ui/const-generics/late-bound-vars/late-bound-in-return-issue-77357.stderr
index 21c8fe6865c..7bef98b1d5d 100644
--- a/tests/ui/const-generics/late-bound-vars/late-bound-in-return-issue-77357.stderr
+++ b/tests/ui/const-generics/late-bound-vars/late-bound-in-return-issue-77357.stderr
@@ -4,5 +4,5 @@ error: cannot capture late-bound lifetime in constant
 LL | fn bug<'a, T>() -> &'static dyn MyTrait<[(); { |x: &'a u32| { x }; 4 }]> {
    |        -- lifetime defined here                     ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/late-bound-vars/late-bound-in-where-issue-83993.stderr b/tests/ui/const-generics/late-bound-vars/late-bound-in-where-issue-83993.stderr
index a66dc8db914..5edbf7bc040 100644
--- a/tests/ui/const-generics/late-bound-vars/late-bound-in-where-issue-83993.stderr
+++ b/tests/ui/const-generics/late-bound-vars/late-bound-in-where-issue-83993.stderr
@@ -6,5 +6,5 @@ LL |     for<'b> [(); {
 LL |         let x: &'b ();
    |                 ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/min_const_generics/const_default_first.stderr b/tests/ui/const-generics/min_const_generics/const_default_first.stderr
index 0d5a393cb7b..b800c6d77b0 100644
--- a/tests/ui/const-generics/min_const_generics/const_default_first.stderr
+++ b/tests/ui/const-generics/min_const_generics/const_default_first.stderr
@@ -4,5 +4,5 @@ error: generic parameters with a default must be trailing
 LL | struct Both<const N: usize=3, T> {
    |                   ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/min_const_generics/default_function_param.stderr b/tests/ui/const-generics/min_const_generics/default_function_param.stderr
index dedad2880c9..247eea3d989 100644
--- a/tests/ui/const-generics/min_const_generics/default_function_param.stderr
+++ b/tests/ui/const-generics/min_const_generics/default_function_param.stderr
@@ -4,5 +4,5 @@ error: defaults for const parameters are only allowed in `struct`, `enum`, `type
 LL | fn foo<const SIZE: usize = 5usize>() {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr b/tests/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr
index bda88597006..03c76150010 100644
--- a/tests/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr
+++ b/tests/ui/const-generics/min_const_generics/forbid-self-no-normalize.stderr
@@ -10,5 +10,5 @@ note: not a concrete type
 LL | impl<T> BindsParam<T> for <T as AlwaysApplicable>::Assoc {
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/min_const_generics/self-ty-in-const-2.stderr b/tests/ui/const-generics/min_const_generics/self-ty-in-const-2.stderr
index 41546292c47..4943f0d70bd 100644
--- a/tests/ui/const-generics/min_const_generics/self-ty-in-const-2.stderr
+++ b/tests/ui/const-generics/min_const_generics/self-ty-in-const-2.stderr
@@ -10,5 +10,5 @@ note: not a concrete type
 LL | impl<T> Baz for Bar<T> {
    |                 ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/nested-type.full.stderr b/tests/ui/const-generics/nested-type.full.stderr
index 6d9f4406504..04dc84ea3cf 100644
--- a/tests/ui/const-generics/nested-type.full.stderr
+++ b/tests/ui/const-generics/nested-type.full.stderr
@@ -6,6 +6,6 @@ LL |     Foo::<17>::value()
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/const-generics/occurs-check/unify-n-nplusone.stderr b/tests/ui/const-generics/occurs-check/unify-n-nplusone.stderr
index 6b8e688fba8..1a251044ec0 100644
--- a/tests/ui/const-generics/occurs-check/unify-n-nplusone.stderr
+++ b/tests/ui/const-generics/occurs-check/unify-n-nplusone.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     arr = bind(arr);
    |           ^^^^^^^^^ encountered a self-referencing constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/occurs-check/unused-substs-1.stderr b/tests/ui/const-generics/occurs-check/unused-substs-1.stderr
index 61d055e8084..8c66c4fefb7 100644
--- a/tests/ui/const-generics/occurs-check/unused-substs-1.stderr
+++ b/tests/ui/const-generics/occurs-check/unused-substs-1.stderr
@@ -14,6 +14,6 @@ LL | where
 LL |     A<N>: Bar<N>;
    |           ^^^^^^ required by this bound in `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/occurs-check/unused-substs-2.stderr b/tests/ui/const-generics/occurs-check/unused-substs-2.stderr
index 9532fc21a31..4b1b9f20559 100644
--- a/tests/ui/const-generics/occurs-check/unused-substs-2.stderr
+++ b/tests/ui/const-generics/occurs-check/unused-substs-2.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     t = foo;
    |         ^^^ cyclic type of infinite size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/occurs-check/unused-substs-3.stderr b/tests/ui/const-generics/occurs-check/unused-substs-3.stderr
index fd8f8b2693a..bcb59705c6b 100644
--- a/tests/ui/const-generics/occurs-check/unused-substs-3.stderr
+++ b/tests/ui/const-generics/occurs-check/unused-substs-3.stderr
@@ -6,6 +6,6 @@ LL |     t = foo;
    |         |
    |         cyclic type of infinite size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/occurs-check/unused-substs-4.stderr b/tests/ui/const-generics/occurs-check/unused-substs-4.stderr
index 5685eedbdec..1e33439f6d7 100644
--- a/tests/ui/const-generics/occurs-check/unused-substs-4.stderr
+++ b/tests/ui/const-generics/occurs-check/unused-substs-4.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     arr = bind(arr);
    |           ^^^^^^^^^ encountered a self-referencing constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/occurs-check/unused-substs-5.stderr b/tests/ui/const-generics/occurs-check/unused-substs-5.stderr
index be289f44f1b..1b3a5492328 100644
--- a/tests/ui/const-generics/occurs-check/unused-substs-5.stderr
+++ b/tests/ui/const-generics/occurs-check/unused-substs-5.stderr
@@ -6,6 +6,6 @@ LL |     x = q::<_, N>(x);
    |         |
    |         cyclic type of infinite size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/outer-lifetime-in-const-generic-default.stderr b/tests/ui/const-generics/outer-lifetime-in-const-generic-default.stderr
index 6b0d18f1989..5a947677678 100644
--- a/tests/ui/const-generics/outer-lifetime-in-const-generic-default.stderr
+++ b/tests/ui/const-generics/outer-lifetime-in-const-generic-default.stderr
@@ -7,5 +7,5 @@ LL |         let x: &'a ();
    = note: lifetime parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr b/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
index 87ff7babe71..07da6ede725 100644
--- a/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
+++ b/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `foo`
 LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) {
    |                                                ^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/parser-error-recovery/issue-89013-no-assoc.stderr b/tests/ui/const-generics/parser-error-recovery/issue-89013-no-assoc.stderr
index 1de24bff469..be3d4f6d25c 100644
--- a/tests/ui/const-generics/parser-error-recovery/issue-89013-no-assoc.stderr
+++ b/tests/ui/const-generics/parser-error-recovery/issue-89013-no-assoc.stderr
@@ -10,5 +10,5 @@ LL - impl Foo<const 3> for Bar {
 LL + impl Foo<3> for Bar {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/parser-error-recovery/issue-89013-type.stderr b/tests/ui/const-generics/parser-error-recovery/issue-89013-type.stderr
index f0d0d90c774..c46c305e085 100644
--- a/tests/ui/const-generics/parser-error-recovery/issue-89013-type.stderr
+++ b/tests/ui/const-generics/parser-error-recovery/issue-89013-type.stderr
@@ -4,5 +4,5 @@ error: missing type to the right of `=`
 LL | impl Foo<N = type 3> for Bar {
    |             ^---- expected type, found keyword `type`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/projection-as-arg-const.stderr b/tests/ui/const-generics/projection-as-arg-const.stderr
index 9f727231edf..88672bce0a7 100644
--- a/tests/ui/const-generics/projection-as-arg-const.stderr
+++ b/tests/ui/const-generics/projection-as-arg-const.stderr
@@ -6,5 +6,5 @@ LL | pub fn foo<const X: <i32 as Identity>::Identity>() {
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/raw-ptr-const-param.full.stderr b/tests/ui/const-generics/raw-ptr-const-param.full.stderr
index 69f1aae5681..aef95bdaa88 100644
--- a/tests/ui/const-generics/raw-ptr-const-param.full.stderr
+++ b/tests/ui/const-generics/raw-ptr-const-param.full.stderr
@@ -4,6 +4,6 @@ error[E0741]: using raw pointers as const generic parameters is forbidden
 LL | struct Const<const P: *const u32>;
    |                       ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/raw-ptr-const-param.min.stderr b/tests/ui/const-generics/raw-ptr-const-param.min.stderr
index 13fbc34e51a..4de98191d5b 100644
--- a/tests/ui/const-generics/raw-ptr-const-param.min.stderr
+++ b/tests/ui/const-generics/raw-ptr-const-param.min.stderr
@@ -6,5 +6,5 @@ LL | struct Const<const P: *const u32>;
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/struct-with-invalid-const-param.stderr b/tests/ui/const-generics/struct-with-invalid-const-param.stderr
index 67f497af505..734a42fe526 100644
--- a/tests/ui/const-generics/struct-with-invalid-const-param.stderr
+++ b/tests/ui/const-generics/struct-with-invalid-const-param.stderr
@@ -4,6 +4,6 @@ error[E0573]: expected type, found const parameter `C`
 LL | struct S<const C: u8>(C);
    |                       ^ not a type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0573`.
diff --git a/tests/ui/const-generics/transmute-const-param-static-reference.min.stderr b/tests/ui/const-generics/transmute-const-param-static-reference.min.stderr
index f18e149464d..25bb7ac8039 100644
--- a/tests/ui/const-generics/transmute-const-param-static-reference.min.stderr
+++ b/tests/ui/const-generics/transmute-const-param-static-reference.min.stderr
@@ -7,5 +7,5 @@ LL | struct Const<const P: &'static ()>;
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/type-dependent/issue-71382.stderr b/tests/ui/const-generics/type-dependent/issue-71382.stderr
index 3f42feea562..69fd6f1c7d5 100644
--- a/tests/ui/const-generics/type-dependent/issue-71382.stderr
+++ b/tests/ui/const-generics/type-dependent/issue-71382.stderr
@@ -6,5 +6,5 @@ LL |     fn test<const FN: fn() -> u8>(&self) -> u8 {
    |
    = note: the only supported types are integers, `bool` and `char`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/type-dependent/type-mismatch.full.stderr b/tests/ui/const-generics/type-dependent/type-mismatch.full.stderr
index 70bc6405798..4fce1aede95 100644
--- a/tests/ui/const-generics/type-dependent/type-mismatch.full.stderr
+++ b/tests/ui/const-generics/type-dependent/type-mismatch.full.stderr
@@ -9,6 +9,6 @@ help: change the type of the numeric literal from `u16` to `u8`
 LL |     assert_eq!(R.method::<1u8>(), 1);
    |                            ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/type-dependent/type-mismatch.min.stderr b/tests/ui/const-generics/type-dependent/type-mismatch.min.stderr
index 70bc6405798..4fce1aede95 100644
--- a/tests/ui/const-generics/type-dependent/type-mismatch.min.stderr
+++ b/tests/ui/const-generics/type-dependent/type-mismatch.min.stderr
@@ -9,6 +9,6 @@ help: change the type of the numeric literal from `u16` to `u8`
 LL |     assert_eq!(R.method::<1u8>(), 1);
    |                            ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/unify_with_nested_expr.stderr b/tests/ui/const-generics/unify_with_nested_expr.stderr
index d4d78b59627..e050254a3e9 100644
--- a/tests/ui/const-generics/unify_with_nested_expr.stderr
+++ b/tests/ui/const-generics/unify_with_nested_expr.stderr
@@ -17,6 +17,6 @@ help: consider specifying the generic argument
 LL |     bar::<N>();
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/unknown_adt.stderr b/tests/ui/const-generics/unknown_adt.stderr
index 0f462dd4728..2e8210772e9 100644
--- a/tests/ui/const-generics/unknown_adt.stderr
+++ b/tests/ui/const-generics/unknown_adt.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `UnknownStruct` in this scope
 LL |     let _: UnknownStruct<7>;
    |            ^^^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/const-generics/unused-type-param-suggestion.stderr b/tests/ui/const-generics/unused-type-param-suggestion.stderr
index 807065ca109..6e985f56666 100644
--- a/tests/ui/const-generics/unused-type-param-suggestion.stderr
+++ b/tests/ui/const-generics/unused-type-param-suggestion.stderr
@@ -7,6 +7,6 @@ LL | struct Example<N>;
    = help: consider removing `N`, referring to it in a field, or using a marker such as `PhantomData`
    = help: if you intended `N` to be a const parameter, use `const N: usize` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0392`.
diff --git a/tests/ui/const-generics/wrong-normalization.stderr b/tests/ui/const-generics/wrong-normalization.stderr
index 658a8406608..2f8dfc895b2 100644
--- a/tests/ui/const-generics/wrong-normalization.stderr
+++ b/tests/ui/const-generics/wrong-normalization.stderr
@@ -6,6 +6,6 @@ LL | impl <I8<{i8::MIN}> as Identity>::Identity {
    |
    = note: either implement a trait on it or create a newtype to wrap it instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0118`.
diff --git a/tests/ui/const_prop/const-prop-ice.stderr b/tests/ui/const_prop/const-prop-ice.stderr
index 3bcf2b2de7b..8a0f831ba84 100644
--- a/tests/ui/const_prop/const-prop-ice.stderr
+++ b/tests/ui/const_prop/const-prop-ice.stderr
@@ -6,5 +6,5 @@ LL |     [0; 3][3u64 as usize];
    |
    = note: `#[deny(unconditional_panic)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const_prop/const-prop-ice2.stderr b/tests/ui/const_prop/const-prop-ice2.stderr
index 2b65ffc2db7..593b0b94ca2 100644
--- a/tests/ui/const_prop/const-prop-ice2.stderr
+++ b/tests/ui/const_prop/const-prop-ice2.stderr
@@ -6,5 +6,5 @@ LL |     println!("{}", xs[Enum::One as usize]);
    |
    = note: `#[deny(unconditional_panic)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/const_prop/const-prop-read-static-in-const.stderr b/tests/ui/const_prop/const-prop-read-static-in-const.stderr
index 793da628587..9af1f7e3a24 100644
--- a/tests/ui/const_prop/const-prop-read-static-in-const.stderr
+++ b/tests/ui/const_prop/const-prop-read-static-in-const.stderr
@@ -12,6 +12,6 @@ help: skipping check that does not even have a feature gate
 LL | const TEST: u8 = MY_STATIC;
    |                  ^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/array-literal-len-mismatch.stderr b/tests/ui/consts/array-literal-len-mismatch.stderr
index 22fec638970..a11506ecb6d 100644
--- a/tests/ui/consts/array-literal-len-mismatch.stderr
+++ b/tests/ui/consts/array-literal-len-mismatch.stderr
@@ -6,6 +6,6 @@ LL | const NUMBERS: [u8; 3] = [10, 20];
    |                     |
    |                     help: consider specifying the actual array length: `2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/assoc_const_generic_impl.stderr b/tests/ui/consts/assoc_const_generic_impl.stderr
index 854b9ce5b22..d826972ce9f 100644
--- a/tests/ui/consts/assoc_const_generic_impl.stderr
+++ b/tests/ui/consts/assoc_const_generic_impl.stderr
@@ -10,6 +10,6 @@ note: the above error was encountered while instantiating `fn <u32 as ZeroSized>
 LL |     42_u32.requires_zero_size();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/async-block.with_feature.stderr b/tests/ui/consts/async-block.with_feature.stderr
index 8c6364aeca6..8228fa29edf 100644
--- a/tests/ui/consts/async-block.with_feature.stderr
+++ b/tests/ui/consts/async-block.with_feature.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-array-oob.stderr b/tests/ui/consts/const-array-oob.stderr
index f1c5f58af47..d481d772894 100644
--- a/tests/ui/consts/const-array-oob.stderr
+++ b/tests/ui/consts/const-array-oob.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const BLUB: [u32; FOO[4]] = [5, 6];
    |                   ^^^^^^ index out of bounds: the length is 3 but the index is 4
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-as-fn.stderr b/tests/ui/consts/const-as-fn.stderr
index 6c51ed89393..8d30321e373 100644
--- a/tests/ui/consts/const-as-fn.stderr
+++ b/tests/ui/consts/const-as-fn.stderr
@@ -9,6 +9,6 @@ LL |     FOO();
    |     |
    |     call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/consts/const-block-const-bound.stderr b/tests/ui/consts/const-block-const-bound.stderr
index b402f0ea915..81790a62f61 100644
--- a/tests/ui/consts/const-block-const-bound.stderr
+++ b/tests/ui/consts/const-block-const-bound.stderr
@@ -6,6 +6,6 @@ LL | const fn f<T: ~const Destruct>(x: T) {}
    |                                |
    |                                the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/const-blocks/fn-call-in-non-const.stderr b/tests/ui/consts/const-blocks/fn-call-in-non-const.stderr
index eb8b8ac7534..b13df67b423 100644
--- a/tests/ui/consts/const-blocks/fn-call-in-non-const.stderr
+++ b/tests/ui/consts/const-blocks/fn-call-in-non-const.stderr
@@ -18,6 +18,6 @@ LL ~     const ARRAY_REPEAT_VALUE: Option<Bar> = no_copy();
 LL ~     let _: [Option<Bar>; 2] = [ARRAY_REPEAT_VALUE; 2];
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/const-blocks/trait-error.stderr b/tests/ui/consts/const-blocks/trait-error.stderr
index 858ffa820e2..36249bf3f6d 100644
--- a/tests/ui/consts/const-blocks/trait-error.stderr
+++ b/tests/ui/consts/const-blocks/trait-error.stderr
@@ -18,6 +18,6 @@ LL ~     const ARRAY_REPEAT_VALUE: Foo<String> = Foo(String::new());
 LL ~     [ARRAY_REPEAT_VALUE; 4];
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/const-call.stderr b/tests/ui/consts/const-call.stderr
index e46bcad0e1d..4e7098a5c8f 100644
--- a/tests/ui/consts/const-call.stderr
+++ b/tests/ui/consts/const-call.stderr
@@ -6,6 +6,6 @@ LL |     let _ = [0; f(2)];
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/const-cast-wrong-type.stderr b/tests/ui/consts/const-cast-wrong-type.stderr
index ee186636e4e..44361f15d8a 100644
--- a/tests/ui/consts/const-cast-wrong-type.stderr
+++ b/tests/ui/consts/const-cast-wrong-type.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL | const b: *const i8 = &a as *const i8;
    |                      ^^^^^^^^^^^^^^^ expected `u8`, found `i8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/const-deref-ptr.stderr b/tests/ui/consts/const-deref-ptr.stderr
index 16eb6b0162d..b102b4d17cc 100644
--- a/tests/ui/consts/const-deref-ptr.stderr
+++ b/tests/ui/consts/const-deref-ptr.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL |     static C: u64 = unsafe {*(0xdeadbeef as *const u64)};
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: 0xdeadbeef[noalloc] is a dangling pointer (it has no provenance)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-err-multi.stderr b/tests/ui/consts/const-err-multi.stderr
index 1ad504b3a80..2fe0b9bb463 100644
--- a/tests/ui/consts/const-err-multi.stderr
+++ b/tests/ui/consts/const-err-multi.stderr
@@ -22,6 +22,6 @@ note: erroneous constant encountered
 LL | pub const D: i8 = 50 - A;
    |                        ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-err4.64bit.stderr b/tests/ui/consts/const-err4.64bit.stderr
index 1cbf78173a7..582a848ca60 100644
--- a/tests/ui/consts/const-err4.64bit.stderr
+++ b/tests/ui/consts/const-err4.64bit.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     Boo = [unsafe { Foo { b: () }.a }; 4][3],
    |                     ^^^^^^^^^^^^^^^ using uninitialized data, but this operation requires initialized memory
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/assign-to-static-within-other-static.stderr b/tests/ui/consts/const-eval/assign-to-static-within-other-static.stderr
index 4b6784acfcf..5300111a6b6 100644
--- a/tests/ui/consts/const-eval/assign-to-static-within-other-static.stderr
+++ b/tests/ui/consts/const-eval/assign-to-static-within-other-static.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL |     FOO = 5;
    |     ^^^^^^^ modifying a static's initial value from another static's initializer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/conditional_array_execution.stderr b/tests/ui/consts/const-eval/conditional_array_execution.stderr
index c3401fbaefe..30034378079 100644
--- a/tests/ui/consts/const-eval/conditional_array_execution.stderr
+++ b/tests/ui/consts/const-eval/conditional_array_execution.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize];
    |                   ^^^^^ attempt to compute `5_u32 - 6_u32`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/const-eval-intrinsic-promotion.stderr b/tests/ui/consts/const-eval/const-eval-intrinsic-promotion.stderr
index ed6a6ee6e0f..d533dcaa6f6 100644
--- a/tests/ui/consts/const-eval/const-eval-intrinsic-promotion.stderr
+++ b/tests/ui/consts/const-eval/const-eval-intrinsic-promotion.stderr
@@ -8,6 +8,6 @@ LL |         &std::intrinsics::size_of::<i32>();
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/consts/const-eval/const-eval-overflow-3.stderr b/tests/ui/consts/const-eval/const-eval-overflow-3.stderr
index 73f421b5b14..0437cd3adb4 100644
--- a/tests/ui/consts/const-eval/const-eval-overflow-3.stderr
+++ b/tests/ui/consts/const-eval/const-eval-overflow-3.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     = [0; (i8::MAX + 1) as usize];
    |           ^^^^^^^^^^^^^ attempt to compute `i8::MAX + 1_i8`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/const-eval-overflow-4.stderr b/tests/ui/consts/const-eval/const-eval-overflow-4.stderr
index 94f4193195c..ce5e59901c1 100644
--- a/tests/ui/consts/const-eval/const-eval-overflow-4.stderr
+++ b/tests/ui/consts/const-eval/const-eval-overflow-4.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     : [u32; (i8::MAX as i8 + 1i8) as usize]
    |             ^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX + 1_i8`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/const-eval-span.stderr b/tests/ui/consts/const-eval/const-eval-span.stderr
index fe33ad4905a..ba11759a710 100644
--- a/tests/ui/consts/const-eval/const-eval-span.stderr
+++ b/tests/ui/consts/const-eval/const-eval-span.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     V = CONSTANT,
    |         ^^^^^^^^ expected `isize`, found `S`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/const-eval/const_fn_target_feature.stderr b/tests/ui/consts/const-eval/const_fn_target_feature.stderr
index 36918b52cd3..0c7c69b794a 100644
--- a/tests/ui/consts/const-eval/const_fn_target_feature.stderr
+++ b/tests/ui/consts/const-eval/const_fn_target_feature.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const B: () = unsafe { avx2_fn() };
    |                        ^^^^^^^^^ calling a function that requires unavailable target features: avx2
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr b/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr
index 82c63dd176d..5f4af25611f 100644
--- a/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr
+++ b/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr
@@ -6,6 +6,6 @@ LL | struct Bug([u8; panic!{"\t"}]);
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/const_panic_stability.e2021.stderr b/tests/ui/consts/const-eval/const_panic_stability.e2021.stderr
index 9e8179181fd..aad36b52b01 100644
--- a/tests/ui/consts/const-eval/const_panic_stability.e2021.stderr
+++ b/tests/ui/consts/const-eval/const_panic_stability.e2021.stderr
@@ -9,5 +9,5 @@ help: you might be missing a string literal to format with
 LL |     panic!("{}", { "foo" });
    |            +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/const_panic_track_caller.stderr b/tests/ui/consts/const-eval/const_panic_track_caller.stderr
index 846458176d6..a7df82705b8 100644
--- a/tests/ui/consts/const-eval/const_panic_track_caller.stderr
+++ b/tests/ui/consts/const-eval/const_panic_track_caller.stderr
@@ -15,6 +15,6 @@ note: inside `X`
 LL | const X: u32 = c();
    |                ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/erroneous-const.stderr b/tests/ui/consts/const-eval/erroneous-const.stderr
index 0e31520fdbb..bd25e96c2cf 100644
--- a/tests/ui/consts/const-eval/erroneous-const.stderr
+++ b/tests/ui/consts/const-eval/erroneous-const.stderr
@@ -10,6 +10,6 @@ note: erroneous constant encountered
 LL |             PrintName::<T>::VOID;
    |             ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/erroneous-const2.stderr b/tests/ui/consts/const-eval/erroneous-const2.stderr
index 4ca44694cd7..6a5839e3dfb 100644
--- a/tests/ui/consts/const-eval/erroneous-const2.stderr
+++ b/tests/ui/consts/const-eval/erroneous-const2.stderr
@@ -10,6 +10,6 @@ note: erroneous constant encountered
 LL |         PrintName::<i32>::VOID;
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr
index 23ba2c2f535..cdde14756e4 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr
@@ -15,6 +15,6 @@ note: inside `FOO`
 LL | const FOO: i32 = foo();
    |                  ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient_fail.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient_fail.stderr
index 2103f842bd5..dfaecfbcd8f 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient_fail.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient_fail.stderr
@@ -6,5 +6,5 @@ LL | const FOO: *const i32 = foo();
    |
    = note: memory only reachable via raw pointers is not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
index de23aafe05c..5ef03427093 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
@@ -9,6 +9,6 @@ LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32)
                ╾ALLOC0╼                         │ ╾──────╼
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
index b6276647350..3903ccd6ade 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
@@ -6,5 +6,5 @@ LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32
    |
    = note: memory only reachable via raw pointers is not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.stderr b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.stderr
index 916344a7b81..d2d323e5a51 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.stderr
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_duplicate.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     intrinsics::const_deallocate(ptr, 4, 4);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC0 has been freed, so this pointer is dangling
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/index-out-of-bounds-never-type.stderr b/tests/ui/consts/const-eval/index-out-of-bounds-never-type.stderr
index 8bcd0300598..4e7ef52f674 100644
--- a/tests/ui/consts/const-eval/index-out-of-bounds-never-type.stderr
+++ b/tests/ui/consts/const-eval/index-out-of-bounds-never-type.stderr
@@ -10,6 +10,6 @@ note: the above error was encountered while instantiating `fn f::<()>`
 LL |     f::<()>();
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/index_out_of_bounds.stderr b/tests/ui/consts/const-eval/index_out_of_bounds.stderr
index 8bb3a0c67d6..d8df74fa010 100644
--- a/tests/ui/consts/const-eval/index_out_of_bounds.stderr
+++ b/tests/ui/consts/const-eval/index_out_of_bounds.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL | static FOO: i32 = [][0];
    |                   ^^^^^ index out of bounds: the length is 0 but the index is 0
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/index_out_of_bounds_propagated.stderr b/tests/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
index d247d691dbb..64c87af4308 100644
--- a/tests/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
+++ b/tests/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
@@ -6,5 +6,5 @@ LL |     array[1];
    |
    = note: `#[deny(unconditional_panic)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/infinite_loop.stderr b/tests/ui/consts/const-eval/infinite_loop.stderr
index f0434a847ce..e7a0a96a1e6 100644
--- a/tests/ui/consts/const-eval/infinite_loop.stderr
+++ b/tests/ui/consts/const-eval/infinite_loop.stderr
@@ -23,5 +23,5 @@ LL | |     }];
    | |_____^
    = note: `#[deny(long_running_const_eval)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/issue-44578.stderr b/tests/ui/consts/const-eval/issue-44578.stderr
index eea42c8ce45..6aabe53011c 100644
--- a/tests/ui/consts/const-eval/issue-44578.stderr
+++ b/tests/ui/consts/const-eval/issue-44578.stderr
@@ -27,6 +27,6 @@ LL |     println!("{}", <Bar<u16, u8> as Foo>::AMT);
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
    = note: this note originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/issue-49296.stderr b/tests/ui/consts/const-eval/issue-49296.stderr
index 2022a16e789..485a11d1f3c 100644
--- a/tests/ui/consts/const-eval/issue-49296.stderr
+++ b/tests/ui/consts/const-eval/issue-49296.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const X: u64 = *wat(42);
    |                ^^^^^^^^ memory access failed: ALLOC0 has been freed, so this pointer is dangling
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/issue-50814-2.mir-opt.stderr b/tests/ui/consts/const-eval/issue-50814-2.mir-opt.stderr
index 6454ce3d1ae..f3ec3200f94 100644
--- a/tests/ui/consts/const-eval/issue-50814-2.mir-opt.stderr
+++ b/tests/ui/consts/const-eval/issue-50814-2.mir-opt.stderr
@@ -16,6 +16,6 @@ note: erroneous constant encountered
 LL |     &<A<T> as Foo<T>>::BAR
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/issue-50814-2.normal.stderr b/tests/ui/consts/const-eval/issue-50814-2.normal.stderr
index c6b1df6c8f4..f552c8fde5b 100644
--- a/tests/ui/consts/const-eval/issue-50814-2.normal.stderr
+++ b/tests/ui/consts/const-eval/issue-50814-2.normal.stderr
@@ -16,6 +16,6 @@ note: the above error was encountered while instantiating `fn foo::<()>`
 LL |     println!("{:x}", foo::<()>() as *const usize as usize);
    |                      ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/issue-50814.stderr b/tests/ui/consts/const-eval/issue-50814.stderr
index 48a20d0bbd0..65c49956f18 100644
--- a/tests/ui/consts/const-eval/issue-50814.stderr
+++ b/tests/ui/consts/const-eval/issue-50814.stderr
@@ -16,6 +16,6 @@ note: the above error was encountered while instantiating `fn foo::<i32>`
 LL |     foo(0);
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/issue-52475.stderr b/tests/ui/consts/const-eval/issue-52475.stderr
index ebf9d12a66a..daaee03787f 100644
--- a/tests/ui/consts/const-eval/issue-52475.stderr
+++ b/tests/ui/consts/const-eval/issue-52475.stderr
@@ -24,5 +24,5 @@ LL | |     }];
    | |_____^
    = note: `#[deny(long_running_const_eval)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/issue-70723.stderr b/tests/ui/consts/const-eval/issue-70723.stderr
index 572a430726f..7cece4ed5d6 100644
--- a/tests/ui/consts/const-eval/issue-70723.stderr
+++ b/tests/ui/consts/const-eval/issue-70723.stderr
@@ -13,5 +13,5 @@ LL | static _X: () = loop {};
    | ^^^^^^^^^^^^^
    = note: `#[deny(long_running_const_eval)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/issue-85155.stderr b/tests/ui/consts/const-eval/issue-85155.stderr
index 3d2c76b7ed0..a88e959a8a6 100644
--- a/tests/ui/consts/const-eval/issue-85155.stderr
+++ b/tests/ui/consts/const-eval/issue-85155.stderr
@@ -10,6 +10,6 @@ note: the above error was encountered while instantiating `fn post_monomorphizat
 LL |     post_monomorphization_error::stdarch_intrinsic::<2>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/issue-85907.stderr b/tests/ui/consts/const-eval/issue-85907.stderr
index fd7b40572c1..519227bc693 100644
--- a/tests/ui/consts/const-eval/issue-85907.stderr
+++ b/tests/ui/consts/const-eval/issue-85907.stderr
@@ -6,5 +6,5 @@ LL |     panic!(123);
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/livedrop.stderr b/tests/ui/consts/const-eval/livedrop.stderr
index d04fdb70ed3..1add8140603 100644
--- a/tests/ui/consts/const-eval/livedrop.stderr
+++ b/tests/ui/consts/const-eval/livedrop.stderr
@@ -7,6 +7,6 @@ LL |     let mut always_returned = None;
 LL |         always_returned = never_returned;
    |         --------------- value is dropped here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/const-eval/match-test-ptr-null.stderr b/tests/ui/consts/const-eval/match-test-ptr-null.stderr
index 05c3951c128..1e14c70fcf1 100644
--- a/tests/ui/consts/const-eval/match-test-ptr-null.stderr
+++ b/tests/ui/consts/const-eval/match-test-ptr-null.stderr
@@ -7,5 +7,5 @@ LL |         match &1 as *const i32 as usize {
    = note: at compile-time, pointers do not have an integer value
    = note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/mod-static-with-const-fn.stderr b/tests/ui/consts/const-eval/mod-static-with-const-fn.stderr
index d127d1d455b..901ae1922c7 100644
--- a/tests/ui/consts/const-eval/mod-static-with-const-fn.stderr
+++ b/tests/ui/consts/const-eval/mod-static-with-const-fn.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL |     *FOO.0.get() = 5;
    |     ^^^^^^^^^^^^^^^^ modifying a static's initial value from another static's initializer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/nonnull_as_ref_ub.stderr b/tests/ui/consts/const-eval/nonnull_as_ref_ub.stderr
index e34f3f43c64..b878c8d1b37 100644
--- a/tests/ui/consts/const-eval/nonnull_as_ref_ub.stderr
+++ b/tests/ui/consts/const-eval/nonnull_as_ref_ub.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const _: () = assert!(42 == *unsafe { NON_NULL.as_ref() });
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: 0x1[noalloc] is a dangling pointer (it has no provenance)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/panic-assoc-never-type.stderr b/tests/ui/consts/const-eval/panic-assoc-never-type.stderr
index 50660664f87..eef39255927 100644
--- a/tests/ui/consts/const-eval/panic-assoc-never-type.stderr
+++ b/tests/ui/consts/const-eval/panic-assoc-never-type.stderr
@@ -20,6 +20,6 @@ LL |     let _ = PrintName::VOID;
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/panic-never-type.stderr b/tests/ui/consts/const-eval/panic-never-type.stderr
index 6bff14a45b1..d3ba3eefb1a 100644
--- a/tests/ui/consts/const-eval/panic-never-type.stderr
+++ b/tests/ui/consts/const-eval/panic-never-type.stderr
@@ -6,6 +6,6 @@ LL | const VOID: ! = panic!();
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/partial_ptr_overwrite.stderr b/tests/ui/consts/const-eval/partial_ptr_overwrite.stderr
index b948e07b92d..3203ca764bb 100644
--- a/tests/ui/consts/const-eval/partial_ptr_overwrite.stderr
+++ b/tests/ui/consts/const-eval/partial_ptr_overwrite.stderr
@@ -7,6 +7,6 @@ LL |         *(ptr as *mut u8) = 123;
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/promoted_const_fn_fail.stderr b/tests/ui/consts/const-eval/promoted_const_fn_fail.stderr
index 2d4e7c83d3e..9aec5479397 100644
--- a/tests/ui/consts/const-eval/promoted_const_fn_fail.stderr
+++ b/tests/ui/consts/const-eval/promoted_const_fn_fail.stderr
@@ -9,6 +9,6 @@ LL |     let x: &'static u8 = &(bar() + 1);
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/consts/const-eval/promoted_const_fn_fail_deny_const_err.stderr b/tests/ui/consts/const-eval/promoted_const_fn_fail_deny_const_err.stderr
index 9ebae3a18a3..71e10478982 100644
--- a/tests/ui/consts/const-eval/promoted_const_fn_fail_deny_const_err.stderr
+++ b/tests/ui/consts/const-eval/promoted_const_fn_fail_deny_const_err.stderr
@@ -9,6 +9,6 @@ LL |     let x: &'static u8 = &(bar() + 1);
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/consts/const-eval/shift_overflow.stderr b/tests/ui/consts/const-eval/shift_overflow.stderr
index e8d4076a61a..901bfa10ee8 100644
--- a/tests/ui/consts/const-eval/shift_overflow.stderr
+++ b/tests/ui/consts/const-eval/shift_overflow.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     X = 1 << ((u32::MAX as u64) + 1),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to shift left by `4294967296_u64`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/size-of-t.stderr b/tests/ui/consts/const-eval/size-of-t.stderr
index abe6410465e..ff09f5aee1c 100644
--- a/tests/ui/consts/const-eval/size-of-t.stderr
+++ b/tests/ui/consts/const-eval/size-of-t.stderr
@@ -7,5 +7,5 @@ LL |     let _arr: [u8; size_of::<T>()];
    = note: type parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/stable-metric/ctfe-fn-call.stderr b/tests/ui/consts/const-eval/stable-metric/ctfe-fn-call.stderr
index a3fd712ca46..f087c9960c2 100644
--- a/tests/ui/consts/const-eval/stable-metric/ctfe-fn-call.stderr
+++ b/tests/ui/consts/const-eval/stable-metric/ctfe-fn-call.stderr
@@ -13,5 +13,5 @@ LL | const X: u32 = call_foo();
    | ^^^^^^^^^^^^
    = note: `#[deny(long_running_const_eval)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/stable-metric/ctfe-labelled-loop.stderr b/tests/ui/consts/const-eval/stable-metric/ctfe-labelled-loop.stderr
index 5808ee35a6b..ecb48fc62a3 100644
--- a/tests/ui/consts/const-eval/stable-metric/ctfe-labelled-loop.stderr
+++ b/tests/ui/consts/const-eval/stable-metric/ctfe-labelled-loop.stderr
@@ -19,5 +19,5 @@ LL | const X: u32 = labelled_loop(19);
    | ^^^^^^^^^^^^
    = note: `#[deny(long_running_const_eval)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/stable-metric/ctfe-recursion.stderr b/tests/ui/consts/const-eval/stable-metric/ctfe-recursion.stderr
index 524c8e55426..a05d792c95c 100644
--- a/tests/ui/consts/const-eval/stable-metric/ctfe-recursion.stderr
+++ b/tests/ui/consts/const-eval/stable-metric/ctfe-recursion.stderr
@@ -13,5 +13,5 @@ LL | const X: u32 = recurse(19);
    | ^^^^^^^^^^^^
    = note: `#[deny(long_running_const_eval)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/transmute-const-promotion.stderr b/tests/ui/consts/const-eval/transmute-const-promotion.stderr
index 434a957f648..3603db03bb2 100644
--- a/tests/ui/consts/const-eval/transmute-const-promotion.stderr
+++ b/tests/ui/consts/const-eval/transmute-const-promotion.stderr
@@ -9,6 +9,6 @@ LL |
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/consts/const-eval/transmute-const.64bit.stderr b/tests/ui/consts/const-eval/transmute-const.64bit.stderr
index 09fd7998695..35a5cabaa67 100644
--- a/tests/ui/consts/const-eval/transmute-const.64bit.stderr
+++ b/tests/ui/consts/const-eval/transmute-const.64bit.stderr
@@ -9,6 +9,6 @@ LL | static FOO: bool = unsafe { mem::transmute(3u8) };
                03                                              │ .
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/ub-enum-overwrite.stderr b/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
index 5750212b44c..2a133c057b3 100644
--- a/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
+++ b/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     unsafe { *p }
    |              ^^ using uninitialized data, but this operation requires initialized memory
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr b/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
index 403fb5e0940..de96821e8b9 100644
--- a/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
+++ b/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
@@ -6,6 +6,6 @@ LL | const B: &[()] = unsafe { A.get_unchecked(3..1) };
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/const-eval/ub-upvars.64bit.stderr b/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
index 097f6b049dc..ef2545b43b1 100644
--- a/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
@@ -9,6 +9,6 @@ LL | const BAD_UPVAR: &dyn FnOnce() = &{
                ╾ALLOC0╼ ╾ALLOC1╼ │ ╾──────╼╾──────╼
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/union-const-eval-field.stderr b/tests/ui/consts/const-eval/union-const-eval-field.stderr
index b299208ae81..b1de225ec58 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.stderr
+++ b/tests/ui/consts/const-eval/union-const-eval-field.stderr
@@ -18,6 +18,6 @@ LL |     FIELD3
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/union_promotion.stderr b/tests/ui/consts/const-eval/union_promotion.stderr
index 42f17de2003..49a285f844f 100644
--- a/tests/ui/consts/const-eval/union_promotion.stderr
+++ b/tests/ui/consts/const-eval/union_promotion.stderr
@@ -11,6 +11,6 @@ LL | |     };
 LL |   }
    |   - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/consts/const-eval/unused-broken-const-late.stderr b/tests/ui/consts/const-eval/unused-broken-const-late.stderr
index cdb70a69dfd..c2cf2f3813c 100644
--- a/tests/ui/consts/const-eval/unused-broken-const-late.stderr
+++ b/tests/ui/consts/const-eval/unused-broken-const-late.stderr
@@ -6,6 +6,6 @@ LL |     const VOID: () = panic!();
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/unused-broken-const.stderr b/tests/ui/consts/const-eval/unused-broken-const.stderr
index fbb10feb76b..fd0ee316fe2 100644
--- a/tests/ui/consts/const-eval/unused-broken-const.stderr
+++ b/tests/ui/consts/const-eval/unused-broken-const.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const FOO: i32 = [][0];
    |                  ^^^^^ index out of bounds: the length is 0 but the index is 0
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/unwind-abort.stderr b/tests/ui/consts/const-eval/unwind-abort.stderr
index 759ce15ab1b..d7330beca7b 100644
--- a/tests/ui/consts/const-eval/unwind-abort.stderr
+++ b/tests/ui/consts/const-eval/unwind-abort.stderr
@@ -16,6 +16,6 @@ LL | const _: () = foo();
    |               ^^^^^
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier-2.stderr b/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier-2.stderr
index 5ec9e2a91f1..aaa8dfa8dca 100644
--- a/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier-2.stderr
+++ b/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier-2.stderr
@@ -4,5 +4,5 @@ error: expected one of `extern` or `fn`, found `WhereIsFerris`
 LL |     const unsafe WhereIsFerris Now() {}
    |                  ^^^^^^^^^^^^^ expected one of `extern` or `fn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier.stderr b/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier.stderr
index ec415ec9d02..82074867b26 100644
--- a/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier.stderr
+++ b/tests/ui/consts/const-extern-fn/issue-68062-const-extern-fns-dont-need-fn-specifier.stderr
@@ -4,5 +4,5 @@ error: expected `fn`, found `PUT_ANYTHING_YOU_WANT_HERE`
 LL |     const extern "Rust" PUT_ANYTHING_YOU_WANT_HERE bug() -> usize { 1 }
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `fn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-external-macro-const-err.stderr b/tests/ui/consts/const-external-macro-const-err.stderr
index 81f6c09ffb8..63f81ea18bc 100644
--- a/tests/ui/consts/const-external-macro-const-err.stderr
+++ b/tests/ui/consts/const-external-macro-const-err.stderr
@@ -6,6 +6,6 @@ LL |     static_assert!(2 + 2 == 5);
    |
    = note: this error originates in the macro `static_assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-float-classify.stderr b/tests/ui/consts/const-float-classify.stderr
index a23d81c0ebe..f0c6c69eac4 100644
--- a/tests/ui/consts/const-float-classify.stderr
+++ b/tests/ui/consts/const-float-classify.stderr
@@ -6,6 +6,6 @@ LL |     x.eq(y)
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/const-fn-mismatch.stderr b/tests/ui/consts/const-fn-mismatch.stderr
index a86a06b3ef1..beaf52c0cfb 100644
--- a/tests/ui/consts/const-fn-mismatch.stderr
+++ b/tests/ui/consts/const-fn-mismatch.stderr
@@ -4,6 +4,6 @@ error[E0379]: functions in traits cannot be declared const
 LL |     const fn f() -> u32 {
    |     ^^^^^ functions in traits cannot be const
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0379`.
diff --git a/tests/ui/consts/const-for-feature-gate.stderr b/tests/ui/consts/const-for-feature-gate.stderr
index 2ea377e09f6..0c24bbad7dd 100644
--- a/tests/ui/consts/const-for-feature-gate.stderr
+++ b/tests/ui/consts/const-for-feature-gate.stderr
@@ -7,6 +7,6 @@ LL |     for _ in 0..5 {}
    = note: see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information
    = help: add `#![feature(const_for)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-len-underflow-separate-spans.next.stderr b/tests/ui/consts/const-len-underflow-separate-spans.next.stderr
index b7b5b648c12..bd2a81f5148 100644
--- a/tests/ui/consts/const-len-underflow-separate-spans.next.stderr
+++ b/tests/ui/consts/const-len-underflow-separate-spans.next.stderr
@@ -10,6 +10,6 @@ note: erroneous constant encountered
 LL |     let a: [i8; LEN] = unimplemented!();
    |                 ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-len-underflow-separate-spans.old.stderr b/tests/ui/consts/const-len-underflow-separate-spans.old.stderr
index b7b5b648c12..bd2a81f5148 100644
--- a/tests/ui/consts/const-len-underflow-separate-spans.old.stderr
+++ b/tests/ui/consts/const-len-underflow-separate-spans.old.stderr
@@ -10,6 +10,6 @@ note: erroneous constant encountered
 LL |     let a: [i8; LEN] = unimplemented!();
    |                 ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-len-underflow-subspans.stderr b/tests/ui/consts/const-len-underflow-subspans.stderr
index 68e958b378d..bfec056cc8a 100644
--- a/tests/ui/consts/const-len-underflow-subspans.stderr
+++ b/tests/ui/consts/const-len-underflow-subspans.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     let a: [i8; ONE - TWO] = unimplemented!();
    |                 ^^^^^^^^^ attempt to compute `1_usize - 2_usize`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-match-check.eval1.stderr b/tests/ui/consts/const-match-check.eval1.stderr
index 27ff5d4cd5c..84890214861 100644
--- a/tests/ui/consts/const-match-check.eval1.stderr
+++ b/tests/ui/consts/const-match-check.eval1.stderr
@@ -16,6 +16,6 @@ help: alternatively, you could prepend the pattern with an underscore to define
 LL |     A = { let _0 = 0; 0 },
    |               +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/consts/const-match-check.eval2.stderr b/tests/ui/consts/const-match-check.eval2.stderr
index 0c74a7b3dd4..0aa12eb86dd 100644
--- a/tests/ui/consts/const-match-check.eval2.stderr
+++ b/tests/ui/consts/const-match-check.eval2.stderr
@@ -16,6 +16,6 @@ help: alternatively, you could prepend the pattern with an underscore to define
 LL |     let x: [i32; { let _0 = 0; 0 }] = [];
    |                        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/consts/const-mut-refs/feature-gate-const_mut_refs.stderr b/tests/ui/consts/const-mut-refs/feature-gate-const_mut_refs.stderr
index 3f9bd37053a..7d8d062dbbe 100644
--- a/tests/ui/consts/const-mut-refs/feature-gate-const_mut_refs.stderr
+++ b/tests/ui/consts/const-mut-refs/feature-gate-const_mut_refs.stderr
@@ -7,6 +7,6 @@ LL | const fn foo(x: &mut i32) -> i32 {
    = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
    = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-points-to-static.64bit.stderr b/tests/ui/consts/const-points-to-static.64bit.stderr
index 86506e6ca01..2bebfbfda01 100644
--- a/tests/ui/consts/const-points-to-static.64bit.stderr
+++ b/tests/ui/consts/const-points-to-static.64bit.stderr
@@ -17,6 +17,6 @@ help: skipping check that does not even have a feature gate
 LL | const TEST: &u8 = &MY_STATIC;
    |                    ^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-ptr-unique.stderr b/tests/ui/consts/const-ptr-unique.stderr
index 83448c3e8d8..c3cc69830df 100644
--- a/tests/ui/consts/const-ptr-unique.stderr
+++ b/tests/ui/consts/const-ptr-unique.stderr
@@ -9,6 +9,6 @@ LL |
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/consts/const-size_of-cycle.stderr b/tests/ui/consts/const-size_of-cycle.stderr
index 46b432357aa..a5679400c2f 100644
--- a/tests/ui/consts/const-size_of-cycle.stderr
+++ b/tests/ui/consts/const-size_of-cycle.stderr
@@ -25,6 +25,6 @@ LL | struct Foo {
    | ^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/consts/const-slice-oob.stderr b/tests/ui/consts/const-slice-oob.stderr
index 746883a79a6..30ec340d2a2 100644
--- a/tests/ui/consts/const-slice-oob.stderr
+++ b/tests/ui/consts/const-slice-oob.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const BAR: u32 = FOO[5];
    |                  ^^^^^^ index out of bounds: the length is 3 but the index is 5
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-suggest-feature.stderr b/tests/ui/consts/const-suggest-feature.stderr
index 3bc1eacf32f..d4a42a880e3 100644
--- a/tests/ui/consts/const-suggest-feature.stderr
+++ b/tests/ui/consts/const-suggest-feature.stderr
@@ -7,6 +7,6 @@ LL |     *std::ptr::null_mut() = 0;
    = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
    = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-try-feature-gate.stderr b/tests/ui/consts/const-try-feature-gate.stderr
index cd1a0630432..79c6ec108b9 100644
--- a/tests/ui/consts/const-try-feature-gate.stderr
+++ b/tests/ui/consts/const-try-feature-gate.stderr
@@ -7,6 +7,6 @@ LL |     Some(())?;
    = note: see issue #74935 <https://github.com/rust-lang/rust/issues/74935> for more information
    = help: add `#![feature(const_try)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-tup-index-span.stderr b/tests/ui/consts/const-tup-index-span.stderr
index d5df0df9525..792e18aa8fd 100644
--- a/tests/ui/consts/const-tup-index-span.stderr
+++ b/tests/ui/consts/const-tup-index-span.stderr
@@ -11,6 +11,6 @@ help: use a trailing comma to create a tuple with one element
 LL | const TUP: (usize,) = (5usize << 64,);
    |                       +            ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/const-unwrap.stderr b/tests/ui/consts/const-unwrap.stderr
index d2cbe4550f4..fee22a1d070 100644
--- a/tests/ui/consts/const-unwrap.stderr
+++ b/tests/ui/consts/const-unwrap.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const BAR: i32 = Option::<i32>::None.unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'called `Option::unwrap()` on a `None` value', $DIR/const-unwrap.rs:7:38
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr b/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr
index ae24f8f6500..e1b8154a287 100644
--- a/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr
+++ b/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const_in_pattern/incomplete-slice.stderr b/tests/ui/consts/const_in_pattern/incomplete-slice.stderr
index be144a87b8b..4ecfb3f1c5a 100644
--- a/tests/ui/consts/const_in_pattern/incomplete-slice.stderr
+++ b/tests/ui/consts/const_in_pattern/incomplete-slice.stderr
@@ -23,6 +23,6 @@ LL ~         E_SL => {},
 LL +         &_ => todo!()
    |
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/consts/const_in_pattern/issue-78057.stderr b/tests/ui/consts/const_in_pattern/issue-78057.stderr
index 5ec68719a97..719295c96a5 100644
--- a/tests/ui/consts/const_in_pattern/issue-78057.stderr
+++ b/tests/ui/consts/const_in_pattern/issue-78057.stderr
@@ -7,5 +7,5 @@ LL |         FOO => {},
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr b/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr
index cced6af499f..1979c297ae4 100644
--- a/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr
+++ b/tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr
@@ -7,5 +7,5 @@ LL |         BAR_BAZ => panic!(),
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const_in_pattern/reject_non_partial_eq.stderr b/tests/ui/consts/const_in_pattern/reject_non_partial_eq.stderr
index 958bf373cf4..d3628a8decb 100644
--- a/tests/ui/consts/const_in_pattern/reject_non_partial_eq.stderr
+++ b/tests/ui/consts/const_in_pattern/reject_non_partial_eq.stderr
@@ -7,5 +7,5 @@ LL |         NO_PARTIAL_EQ_NONE => println!("NO_PARTIAL_EQ_NONE"),
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const_let_refutable.stderr b/tests/ui/consts/const_let_refutable.stderr
index d6119028f5b..5aedfb03f6c 100644
--- a/tests/ui/consts/const_let_refutable.stderr
+++ b/tests/ui/consts/const_let_refutable.stderr
@@ -6,6 +6,6 @@ LL | const fn slice(&[a, b]: &[i32]) -> i32 {
    |
    = note: the matched value is of type `&[i32]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/consts/const_unsafe_unreachable_ub.stderr b/tests/ui/consts/const_unsafe_unreachable_ub.stderr
index 593a51bfe8f..6394563e2bb 100644
--- a/tests/ui/consts/const_unsafe_unreachable_ub.stderr
+++ b/tests/ui/consts/const_unsafe_unreachable_ub.stderr
@@ -16,6 +16,6 @@ note: inside `BAR`
 LL | const BAR: bool = unsafe { foo(false) };
    |                            ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/control-flow/assert.stderr b/tests/ui/consts/control-flow/assert.stderr
index 8b1ca183de9..2f863daf760 100644
--- a/tests/ui/consts/control-flow/assert.stderr
+++ b/tests/ui/consts/control-flow/assert.stderr
@@ -6,6 +6,6 @@ LL | const _: () = assert!(false);
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/control-flow/issue-46843.stderr b/tests/ui/consts/control-flow/issue-46843.stderr
index 66227f61e35..69bf78839be 100644
--- a/tests/ui/consts/control-flow/issue-46843.stderr
+++ b/tests/ui/consts/control-flow/issue-46843.stderr
@@ -6,6 +6,6 @@ LL | pub const Q: i32 = match non_const() {
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/control-flow/issue-50577.stderr b/tests/ui/consts/control-flow/issue-50577.stderr
index a931c89f47e..1556c6f9c55 100644
--- a/tests/ui/consts/control-flow/issue-50577.stderr
+++ b/tests/ui/consts/control-flow/issue-50577.stderr
@@ -8,6 +8,6 @@ LL |         Drop = assert_eq!(1, 1),
    = help: consider adding an `else` block that evaluates to the expected type
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0317`.
diff --git a/tests/ui/consts/control-flow/try.stderr b/tests/ui/consts/control-flow/try.stderr
index 5aeec8fbf86..7351f5c0a6f 100644
--- a/tests/ui/consts/control-flow/try.stderr
+++ b/tests/ui/consts/control-flow/try.stderr
@@ -7,6 +7,6 @@ LL |     x?;
    = note: see issue #74935 <https://github.com/rust-lang/rust/issues/74935> for more information
    = help: add `#![feature(const_try)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr b/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
index fa20077da7e..24572040b91 100644
--- a/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
+++ b/tests/ui/consts/ct-var-in-collect_all_mismatches.stderr
@@ -17,6 +17,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: Bar<N>, const N: usize> Foo<T, N> {
    |       ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/dangling-alloc-id-ice.stderr b/tests/ui/consts/dangling-alloc-id-ice.stderr
index 0a1cca4ca4d..e14204c09e5 100644
--- a/tests/ui/consts/dangling-alloc-id-ice.stderr
+++ b/tests/ui/consts/dangling-alloc-id-ice.stderr
@@ -4,5 +4,5 @@ error: encountered dangling pointer in final constant
 LL | const FOO: &() = {
    | ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/dangling_raw_ptr.stderr b/tests/ui/consts/dangling_raw_ptr.stderr
index bdfe1e4effe..5a428355034 100644
--- a/tests/ui/consts/dangling_raw_ptr.stderr
+++ b/tests/ui/consts/dangling_raw_ptr.stderr
@@ -4,5 +4,5 @@ error: encountered dangling pointer in final constant
 LL | const FOO: *const u32 = {
    | ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/drop_box.stderr b/tests/ui/consts/drop_box.stderr
index 62324939b08..3f4b6f34826 100644
--- a/tests/ui/consts/drop_box.stderr
+++ b/tests/ui/consts/drop_box.stderr
@@ -6,6 +6,6 @@ LL | const fn f<T>(_: Box<T>) {}
    |               |
    |               the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/drop_zst.stderr b/tests/ui/consts/drop_zst.stderr
index 37758a4cbda..e3c6785290d 100644
--- a/tests/ui/consts/drop_zst.stderr
+++ b/tests/ui/consts/drop_zst.stderr
@@ -4,6 +4,6 @@ error[E0493]: destructor of `S` cannot be evaluated at compile-time
 LL |     let s = S;
    |         ^ the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/escaping-bound-var.stderr b/tests/ui/consts/escaping-bound-var.stderr
index d26ae2cee1c..a943c84e3b2 100644
--- a/tests/ui/consts/escaping-bound-var.stderr
+++ b/tests/ui/consts/escaping-bound-var.stderr
@@ -16,5 +16,5 @@ LL | fn test<'a>(
 LL |     let x: &'a ();
    |             ^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/consts/gate-do-not-const-check.stderr b/tests/ui/consts/gate-do-not-const-check.stderr
index 3bb1360166a..27a2c23a678 100644
--- a/tests/ui/consts/gate-do-not-const-check.stderr
+++ b/tests/ui/consts/gate-do-not-const-check.stderr
@@ -6,6 +6,6 @@ LL | #[rustc_do_not_const_check]
    |
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/inline_asm.stderr b/tests/ui/consts/inline_asm.stderr
index 65a828d118c..0f71ab4b97f 100644
--- a/tests/ui/consts/inline_asm.stderr
+++ b/tests/ui/consts/inline_asm.stderr
@@ -4,6 +4,6 @@ error[E0015]: inline assembly is not allowed in constants
 LL | const _: () = unsafe { asm!("nop") };
    |                        ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/intrinsic_without_const_stab.stderr b/tests/ui/consts/intrinsic_without_const_stab.stderr
index b32b6398ece..e3143080c5f 100644
--- a/tests/ui/consts/intrinsic_without_const_stab.stderr
+++ b/tests/ui/consts/intrinsic_without_const_stab.stderr
@@ -6,6 +6,6 @@ LL |     unsafe { copy(src, dst, count) }
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/intrinsic_without_const_stab_fail.stderr b/tests/ui/consts/intrinsic_without_const_stab_fail.stderr
index fcbb3724567..8ade68eb2a9 100644
--- a/tests/ui/consts/intrinsic_without_const_stab_fail.stderr
+++ b/tests/ui/consts/intrinsic_without_const_stab_fail.stderr
@@ -6,6 +6,6 @@ LL |     unsafe { copy(src, dst, count) }
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/invalid-const-in-body.stderr b/tests/ui/consts/invalid-const-in-body.stderr
index 3be65835946..b8944abba26 100644
--- a/tests/ui/consts/invalid-const-in-body.stderr
+++ b/tests/ui/consts/invalid-const-in-body.stderr
@@ -4,5 +4,5 @@ error: expected at least one digit in exponent
 LL |     2.0E
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/invalid-inline-const-in-match-arm.stderr b/tests/ui/consts/invalid-inline-const-in-match-arm.stderr
index 257ecd7f3cf..db7db4b6131 100644
--- a/tests/ui/consts/invalid-inline-const-in-match-arm.stderr
+++ b/tests/ui/consts/invalid-inline-const-in-match-arm.stderr
@@ -8,6 +8,6 @@ LL |         const { (|| {})() } => {}
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/invalid-union.64bit.stderr b/tests/ui/consts/invalid-union.64bit.stderr
index 45f999eb23c..e8a0a9955ad 100644
--- a/tests/ui/consts/invalid-union.64bit.stderr
+++ b/tests/ui/consts/invalid-union.64bit.stderr
@@ -23,6 +23,6 @@ LL |     let _: &'static _ = &C;
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-104609.stderr b/tests/ui/consts/issue-104609.stderr
index 00360c44d61..8d0526978ed 100644
--- a/tests/ui/consts/issue-104609.stderr
+++ b/tests/ui/consts/issue-104609.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `oops` in this scope
 LL |     oops;
    |     ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/consts/issue-104768.stderr b/tests/ui/consts/issue-104768.stderr
index 55b2b6f0435..8a4a41e4d68 100644
--- a/tests/ui/consts/issue-104768.stderr
+++ b/tests/ui/consts/issue-104768.stderr
@@ -7,6 +7,6 @@ LL | const A: &_ = 0_u32;
    |          not allowed in type signatures
    |          help: replace with the correct type: `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/consts/issue-17458.stderr b/tests/ui/consts/issue-17458.stderr
index 8936c8d84ec..766657d12a1 100644
--- a/tests/ui/consts/issue-17458.stderr
+++ b/tests/ui/consts/issue-17458.stderr
@@ -7,5 +7,5 @@ LL | static X: usize = unsafe { core::ptr::null::<usize>() as usize };
    = note: at compile-time, pointers do not have an integer value
    = note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/issue-17718-constants-not-static.stderr b/tests/ui/consts/issue-17718-constants-not-static.stderr
index 8f3acae7139..42d2a9acdc7 100644
--- a/tests/ui/consts/issue-17718-constants-not-static.stderr
+++ b/tests/ui/consts/issue-17718-constants-not-static.stderr
@@ -7,6 +7,6 @@ LL | fn foo() -> &'static usize { &id(FOO) }
    |                              |temporary value created here
    |                              returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/consts/issue-18294.stderr b/tests/ui/consts/issue-18294.stderr
index e0cbd2a216d..8df40cabaaa 100644
--- a/tests/ui/consts/issue-18294.stderr
+++ b/tests/ui/consts/issue-18294.stderr
@@ -7,5 +7,5 @@ LL |     const Y: usize = unsafe { &X as *const u32 as usize };
    = note: at compile-time, pointers do not have an integer value
    = note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/issue-25826.stderr b/tests/ui/consts/issue-25826.stderr
index 780edd2149f..7d21020da64 100644
--- a/tests/ui/consts/issue-25826.stderr
+++ b/tests/ui/consts/issue-25826.stderr
@@ -6,5 +6,5 @@ LL |     const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const ()
    |
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/issue-28113.stderr b/tests/ui/consts/issue-28113.stderr
index 1294cc99bf7..01bbe4bc9b9 100644
--- a/tests/ui/consts/issue-28113.stderr
+++ b/tests/ui/consts/issue-28113.stderr
@@ -8,6 +8,6 @@ LL |     || -> u8 { 5 }()
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/issue-32829.stderr b/tests/ui/consts/issue-32829.stderr
index cae5163f0df..8eee87af8e1 100644
--- a/tests/ui/consts/issue-32829.stderr
+++ b/tests/ui/consts/issue-32829.stderr
@@ -6,6 +6,6 @@ LL | static S : u64 = { { panic!("foo"); 0 } };
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-3521.stderr b/tests/ui/consts/issue-3521.stderr
index aa42772f12d..70ce9b2d6a0 100644
--- a/tests/ui/consts/issue-3521.stderr
+++ b/tests/ui/consts/issue-3521.stderr
@@ -7,6 +7,6 @@ LL |     let foo: isize = 100;
 LL |         Bar = foo
    |               ^^^ non-constant value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/consts/issue-36163.stderr b/tests/ui/consts/issue-36163.stderr
index 6fcfe3ed28c..4f2d92ba3cd 100644
--- a/tests/ui/consts/issue-36163.stderr
+++ b/tests/ui/consts/issue-36163.stderr
@@ -27,6 +27,6 @@ LL |     B = A,
    |         ^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/consts/issue-44415.stderr b/tests/ui/consts/issue-44415.stderr
index 01d24a62081..adb5747c424 100644
--- a/tests/ui/consts/issue-44415.stderr
+++ b/tests/ui/consts/issue-44415.stderr
@@ -25,6 +25,6 @@ LL | struct Foo {
    | ^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/consts/issue-52023-array-size-pointer-cast.stderr b/tests/ui/consts/issue-52023-array-size-pointer-cast.stderr
index 9a3d5716e00..1a47b82a7d3 100644
--- a/tests/ui/consts/issue-52023-array-size-pointer-cast.stderr
+++ b/tests/ui/consts/issue-52023-array-size-pointer-cast.stderr
@@ -7,5 +7,5 @@ LL |     let _ = [0; (&0 as *const i32) as usize];
    = note: at compile-time, pointers do not have an integer value
    = note: avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/issue-52060.stderr b/tests/ui/consts/issue-52060.stderr
index 95e5f2a8282..27d00ad0442 100644
--- a/tests/ui/consts/issue-52060.stderr
+++ b/tests/ui/consts/issue-52060.stderr
@@ -6,6 +6,6 @@ LL | static B: [u32; 1] = [0; A.len()];
    |
    = help: consider extracting the value of the `static` to a `const`, and referring to that
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0013`.
diff --git a/tests/ui/consts/issue-63952.64bit.stderr b/tests/ui/consts/issue-63952.64bit.stderr
index a6edbf9321b..c1d7b75af88 100644
--- a/tests/ui/consts/issue-63952.64bit.stderr
+++ b/tests/ui/consts/issue-63952.64bit.stderr
@@ -9,6 +9,6 @@ LL | const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
                ╾ALLOC0╼ ff ff ff ff ff ff ff ff │ ╾──────╼........
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-64506.stderr b/tests/ui/consts/issue-64506.stderr
index 2fe84245b3e..4cc2b713741 100644
--- a/tests/ui/consts/issue-64506.stderr
+++ b/tests/ui/consts/issue-64506.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     let x = unsafe { Foo { b: () }.a };
    |                      ^^^^^^^^^^^^^^^ constructing invalid value at .inner: encountered a value of uninhabited type `AnonPipe`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-68542-closure-in-array-len.stderr b/tests/ui/consts/issue-68542-closure-in-array-len.stderr
index d23513ed7ff..3c0408cbedf 100644
--- a/tests/ui/consts/issue-68542-closure-in-array-len.stderr
+++ b/tests/ui/consts/issue-68542-closure-in-array-len.stderr
@@ -8,6 +8,6 @@ LL |     a: [(); (|| { 0 })()]
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/issue-70942-trait-vs-impl-mismatch.stderr b/tests/ui/consts/issue-70942-trait-vs-impl-mismatch.stderr
index 1597120fb5c..0393316f166 100644
--- a/tests/ui/consts/issue-70942-trait-vs-impl-mismatch.stderr
+++ b/tests/ui/consts/issue-70942-trait-vs-impl-mismatch.stderr
@@ -10,6 +10,6 @@ note: type in trait
 LL |     const VALUE: usize;
    |                  ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0326`.
diff --git a/tests/ui/consts/issue-73976-monomorphic.stderr b/tests/ui/consts/issue-73976-monomorphic.stderr
index b23796db4f1..ef754b23ff0 100644
--- a/tests/ui/consts/issue-73976-monomorphic.stderr
+++ b/tests/ui/consts/issue-73976-monomorphic.stderr
@@ -8,6 +8,6 @@ note: impl defined here, but it is not `const`
   --> $SRC_DIR/core/src/any.rs:LL:COL
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/issue-76064.stderr b/tests/ui/consts/issue-76064.stderr
index 67b2e90db75..fabebdb1a77 100644
--- a/tests/ui/consts/issue-76064.stderr
+++ b/tests/ui/consts/issue-76064.stderr
@@ -6,6 +6,6 @@ LL | struct Bug([u8; panic!("panic")]);
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-79137-toogeneric.stderr b/tests/ui/consts/issue-79137-toogeneric.stderr
index efe4fd22e54..18bdde45e2c 100644
--- a/tests/ui/consts/issue-79137-toogeneric.stderr
+++ b/tests/ui/consts/issue-79137-toogeneric.stderr
@@ -4,5 +4,5 @@ error: constant pattern depends on a generic parameter
 LL |     matches!(GetVariantCount::<T>::VALUE, GetVariantCount::<T>::VALUE)
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/issue-79690.64bit.stderr b/tests/ui/consts/issue-79690.64bit.stderr
index af59729d438..e99ce078c11 100644
--- a/tests/ui/consts/issue-79690.64bit.stderr
+++ b/tests/ui/consts/issue-79690.64bit.stderr
@@ -9,6 +9,6 @@ LL | const G: Fat = unsafe { Transmute { t: FOO }.u };
                ╾ALLOC0╼ ╾ALLOC1╼ │ ╾──────╼╾──────╼
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-87046.stderr b/tests/ui/consts/issue-87046.stderr
index d0dbb21cee0..0f965e1ac3f 100644
--- a/tests/ui/consts/issue-87046.stderr
+++ b/tests/ui/consts/issue-87046.stderr
@@ -4,5 +4,5 @@ error: cannot use unsized non-slice type `Username` in constant patterns
 LL |             ROOT_USER => true,
    |             ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/issue-90878-3.stderr b/tests/ui/consts/issue-90878-3.stderr
index 1bcc0eb3787..46b380d0f74 100644
--- a/tests/ui/consts/issue-90878-3.stderr
+++ b/tests/ui/consts/issue-90878-3.stderr
@@ -6,6 +6,6 @@ LL |     |x: usize| [0; x];
    |      |
    |      this would need to be a `const`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/consts/issue-90878.stderr b/tests/ui/consts/issue-90878.stderr
index c038fc622d4..9b7cd97be22 100644
--- a/tests/ui/consts/issue-90878.stderr
+++ b/tests/ui/consts/issue-90878.stderr
@@ -6,6 +6,6 @@ LL |     |x: usize| [0; x];
    |      |
    |      this would need to be a `const`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/consts/issue-miri-1910.stderr b/tests/ui/consts/issue-miri-1910.stderr
index af0f77c6767..7ad53800ad7 100644
--- a/tests/ui/consts/issue-miri-1910.stderr
+++ b/tests/ui/consts/issue-miri-1910.stderr
@@ -15,6 +15,6 @@ LL |     (&foo as *const _ as *const u8).add(one_and_a_half_pointers).read();
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/match_ice.stderr b/tests/ui/consts/match_ice.stderr
index 342d94ed31c..fb5cbe0ed89 100644
--- a/tests/ui/consts/match_ice.stderr
+++ b/tests/ui/consts/match_ice.stderr
@@ -7,5 +7,5 @@ LL |         C => {}
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr b/tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr
index 3845068d841..bfaccf1db1c 100644
--- a/tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr
+++ b/tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr
@@ -6,5 +6,5 @@ LL |     unsafe { x == y }
    |
    = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/mir_check_nonconst.stderr b/tests/ui/consts/mir_check_nonconst.stderr
index 1e0652722ff..ea6a8b8ee4a 100644
--- a/tests/ui/consts/mir_check_nonconst.stderr
+++ b/tests/ui/consts/mir_check_nonconst.stderr
@@ -7,6 +7,6 @@ LL | static foo: Foo = bar();
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/miri_unleashed/abi-mismatch.stderr b/tests/ui/consts/miri_unleashed/abi-mismatch.stderr
index cf3fd88d034..51364b01a2d 100644
--- a/tests/ui/consts/miri_unleashed/abi-mismatch.stderr
+++ b/tests/ui/consts/miri_unleashed/abi-mismatch.stderr
@@ -23,6 +23,6 @@ help: skipping check that does not even have a feature gate
 LL |     my_fn();
    |     ^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/assoc_const.stderr b/tests/ui/consts/miri_unleashed/assoc_const.stderr
index b129aef3452..3303a784265 100644
--- a/tests/ui/consts/miri_unleashed/assoc_const.stderr
+++ b/tests/ui/consts/miri_unleashed/assoc_const.stderr
@@ -35,6 +35,6 @@ help: skipping check that does not even have a feature gate
 LL |     const F: u32 = (U::X, 42).1;
    |                    ^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/assoc_const_2.stderr b/tests/ui/consts/miri_unleashed/assoc_const_2.stderr
index 46408f6748d..e923d95b755 100644
--- a/tests/ui/consts/miri_unleashed/assoc_const_2.stderr
+++ b/tests/ui/consts/miri_unleashed/assoc_const_2.stderr
@@ -18,6 +18,6 @@ LL |     let y = <String as Bar<String>>::F;
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/box.stderr b/tests/ui/consts/miri_unleashed/box.stderr
index 407f5d8cb11..5229f1e50cd 100644
--- a/tests/ui/consts/miri_unleashed/box.stderr
+++ b/tests/ui/consts/miri_unleashed/box.stderr
@@ -22,6 +22,6 @@ help: skipping check that does not even have a feature gate
 LL |     &mut *(Box::new(0))
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/drop.stderr b/tests/ui/consts/miri_unleashed/drop.stderr
index 4f60b882069..5c415b5bac1 100644
--- a/tests/ui/consts/miri_unleashed/drop.stderr
+++ b/tests/ui/consts/miri_unleashed/drop.stderr
@@ -19,6 +19,6 @@ help: skipping check that does not even have a feature gate
 LL |     let _v: Vec<i32> = Vec::new();
    |         ^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr b/tests/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr
index 45ed88b1bb0..833e2745838 100644
--- a/tests/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr
+++ b/tests/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr
@@ -6,6 +6,6 @@ LL |     const F: u32 = (U::X, 42).1;
    |                    |
    |                    the destructor for this type cannot be evaluated in constants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/miri_unleashed/inline_asm.stderr b/tests/ui/consts/miri_unleashed/inline_asm.stderr
index 6317cd88267..e9643f02840 100644
--- a/tests/ui/consts/miri_unleashed/inline_asm.stderr
+++ b/tests/ui/consts/miri_unleashed/inline_asm.stderr
@@ -12,6 +12,6 @@ help: skipping check that does not even have a feature gate
 LL |     unsafe { asm!("nop"); }
    |              ^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/mutable_references.stderr b/tests/ui/consts/miri_unleashed/mutable_references.stderr
index 3ed96701ab0..39298842a33 100644
--- a/tests/ui/consts/miri_unleashed/mutable_references.stderr
+++ b/tests/ui/consts/miri_unleashed/mutable_references.stderr
@@ -32,6 +32,6 @@ help: skipping check that does not even have a feature gate
 LL | static OH_YES: &mut i32 = &mut 42;
    |                           ^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/consts/miri_unleashed/mutating_global.stderr b/tests/ui/consts/miri_unleashed/mutating_global.stderr
index c8770c8d76a..c38e2d44d89 100644
--- a/tests/ui/consts/miri_unleashed/mutating_global.stderr
+++ b/tests/ui/consts/miri_unleashed/mutating_global.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL |         GLOBAL = 99
    |         ^^^^^^^^^^^ modifying a static's initial value from another static's initializer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/non_const_fn.stderr b/tests/ui/consts/miri_unleashed/non_const_fn.stderr
index 57836f7966d..cc893896ecf 100644
--- a/tests/ui/consts/miri_unleashed/non_const_fn.stderr
+++ b/tests/ui/consts/miri_unleashed/non_const_fn.stderr
@@ -12,6 +12,6 @@ help: skipping check that does not even have a feature gate
 LL | static C: () = foo();
    |                ^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/miri_unleashed/raw_mutable_const.stderr b/tests/ui/consts/miri_unleashed/raw_mutable_const.stderr
index 5acdcdd95e8..f4abaecac5e 100644
--- a/tests/ui/consts/miri_unleashed/raw_mutable_const.stderr
+++ b/tests/ui/consts/miri_unleashed/raw_mutable_const.stderr
@@ -14,5 +14,5 @@ help: skipping check that does not even have a feature gate
 LL | const MUTABLE_BEHIND_RAW: *mut i32 = &UnsafeCell::new(42) as *const _ as *mut _;
    |                                      ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/consts/missing-larger-array-impl.stderr b/tests/ui/consts/missing-larger-array-impl.stderr
index fe9d0f6e6ed..acf38d00ec6 100644
--- a/tests/ui/consts/missing-larger-array-impl.stderr
+++ b/tests/ui/consts/missing-larger-array-impl.stderr
@@ -15,6 +15,6 @@ LL |     <[X; 35] as Default>::default();
              [T; 7]
            and 27 others
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/missing_span_in_backtrace.stderr b/tests/ui/consts/missing_span_in_backtrace.stderr
index 6860cee4184..ef9f6345691 100644
--- a/tests/ui/consts/missing_span_in_backtrace.stderr
+++ b/tests/ui/consts/missing_span_in_backtrace.stderr
@@ -23,6 +23,6 @@ note: inside `X`
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/nested_erroneous_ctfe.stderr b/tests/ui/consts/nested_erroneous_ctfe.stderr
index b6a1725076b..db298246e7c 100644
--- a/tests/ui/consts/nested_erroneous_ctfe.stderr
+++ b/tests/ui/consts/nested_erroneous_ctfe.stderr
@@ -7,6 +7,6 @@ LL |     [9; || [9; []]];
    = note: expected type `usize`
              found array `[_; 0]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/partial_qualif.stderr b/tests/ui/consts/partial_qualif.stderr
index 32c25be2173..05e0eeee133 100644
--- a/tests/ui/consts/partial_qualif.stderr
+++ b/tests/ui/consts/partial_qualif.stderr
@@ -4,6 +4,6 @@ error[E0492]: constants cannot refer to interior mutable data
 LL |     &{a}
    |     ^^^^ this borrow of an interior mutable value may end up in the final value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0492`.
diff --git a/tests/ui/consts/qualif_overwrite.stderr b/tests/ui/consts/qualif_overwrite.stderr
index 86a669c433d..976cf7bd79e 100644
--- a/tests/ui/consts/qualif_overwrite.stderr
+++ b/tests/ui/consts/qualif_overwrite.stderr
@@ -4,6 +4,6 @@ error[E0492]: constants cannot refer to interior mutable data
 LL |     &{a}
    |     ^^^^ this borrow of an interior mutable value may end up in the final value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0492`.
diff --git a/tests/ui/consts/qualif_overwrite_2.stderr b/tests/ui/consts/qualif_overwrite_2.stderr
index 9eb123d0b01..a107c4a5c6d 100644
--- a/tests/ui/consts/qualif_overwrite_2.stderr
+++ b/tests/ui/consts/qualif_overwrite_2.stderr
@@ -4,6 +4,6 @@ error[E0492]: constants cannot refer to interior mutable data
 LL |     &{a.0}
    |     ^^^^^^ this borrow of an interior mutable value may end up in the final value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0492`.
diff --git a/tests/ui/consts/raw-ptr-const.stderr b/tests/ui/consts/raw-ptr-const.stderr
index 82f782fab7f..9aef78505c0 100644
--- a/tests/ui/consts/raw-ptr-const.stderr
+++ b/tests/ui/consts/raw-ptr-const.stderr
@@ -6,5 +6,5 @@ LL | const CONST_RAW: *const Vec<i32> = &Vec::new() as *const _;
    |
    = note: memory only reachable via raw pointers is not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/recursive-zst-static.default.stderr b/tests/ui/consts/recursive-zst-static.default.stderr
index d592b5aeef5..3bbb685a678 100644
--- a/tests/ui/consts/recursive-zst-static.default.stderr
+++ b/tests/ui/consts/recursive-zst-static.default.stderr
@@ -21,6 +21,6 @@ LL | | }
    | |_^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/consts/recursive-zst-static.unleash.stderr b/tests/ui/consts/recursive-zst-static.unleash.stderr
index d592b5aeef5..3bbb685a678 100644
--- a/tests/ui/consts/recursive-zst-static.unleash.stderr
+++ b/tests/ui/consts/recursive-zst-static.unleash.stderr
@@ -21,6 +21,6 @@ LL | | }
    | |_^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/consts/recursive.stderr b/tests/ui/consts/recursive.stderr
index 60ce64d2a1e..0046005c74f 100644
--- a/tests/ui/consts/recursive.stderr
+++ b/tests/ui/consts/recursive.stderr
@@ -31,6 +31,6 @@ note: inside `X`
 LL | const X: () = f(1);
    |               ^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/stable-precise-live-drops-in-libcore.stderr b/tests/ui/consts/stable-precise-live-drops-in-libcore.stderr
index 5f70391eec2..323c49b1d1b 100644
--- a/tests/ui/consts/stable-precise-live-drops-in-libcore.stderr
+++ b/tests/ui/consts/stable-precise-live-drops-in-libcore.stderr
@@ -7,6 +7,6 @@ LL |     pub const fn unwrap(self) -> T {
 LL |     }
    |     - value is dropped here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/static_mut_containing_mut_ref2.mut_refs.stderr b/tests/ui/consts/static_mut_containing_mut_ref2.mut_refs.stderr
index 8db75dd63cf..3d0de233569 100644
--- a/tests/ui/consts/static_mut_containing_mut_ref2.mut_refs.stderr
+++ b/tests/ui/consts/static_mut_containing_mut_ref2.mut_refs.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL | pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 42; };
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ modifying a static's initial value from another static's initializer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/static_mut_containing_mut_ref2.stock.stderr b/tests/ui/consts/static_mut_containing_mut_ref2.stock.stderr
index 5cdcea23231..3d5b012d42f 100644
--- a/tests/ui/consts/static_mut_containing_mut_ref2.stock.stderr
+++ b/tests/ui/consts/static_mut_containing_mut_ref2.stock.stderr
@@ -7,6 +7,6 @@ LL | pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 4
    = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
    = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/static_mut_containing_mut_ref3.stderr b/tests/ui/consts/static_mut_containing_mut_ref3.stderr
index 91f9dbd8d0b..be84608acf7 100644
--- a/tests/ui/consts/static_mut_containing_mut_ref3.stderr
+++ b/tests/ui/consts/static_mut_containing_mut_ref3.stderr
@@ -4,6 +4,6 @@ error[E0080]: could not evaluate static initializer
 LL | static mut BAR: () = unsafe { FOO.0 = 99; };
    |                               ^^^^^^^^^^ modifying a static's initial value from another static's initializer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/timeout.stderr b/tests/ui/consts/timeout.stderr
index 799b5ec8dd9..6bfa06d86d1 100644
--- a/tests/ui/consts/timeout.stderr
+++ b/tests/ui/consts/timeout.stderr
@@ -11,5 +11,5 @@ LL | static ROOK_ATTACKS_TABLE: () = {
    = note: `#[deny(long_running_const_eval)]` on by default
    = note: this error originates in the macro `uint_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/transmute-size-mismatch-before-typeck.stderr b/tests/ui/consts/transmute-size-mismatch-before-typeck.stderr
index 4e8470173a1..6bc7e7203aa 100644
--- a/tests/ui/consts/transmute-size-mismatch-before-typeck.stderr
+++ b/tests/ui/consts/transmute-size-mismatch-before-typeck.stderr
@@ -7,6 +7,6 @@ LL | const ZST: &[u8] = unsafe { std::mem::transmute(1usize) };
    = note: source type: `usize` (word size)
    = note: target type: `&[u8]` (2 * word size)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/consts/try-operator.stderr b/tests/ui/consts/try-operator.stderr
index f6a651c5e66..bb8f606edf8 100644
--- a/tests/ui/consts/try-operator.stderr
+++ b/tests/ui/consts/try-operator.stderr
@@ -4,6 +4,6 @@ error[E0635]: unknown feature `const_convert`
 LL | #![feature(const_convert)]
    |            ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0635`.
diff --git a/tests/ui/consts/uninhabited-const-issue-61744.stderr b/tests/ui/consts/uninhabited-const-issue-61744.stderr
index c92824a0d1a..c6dd11ee5db 100644
--- a/tests/ui/consts/uninhabited-const-issue-61744.stderr
+++ b/tests/ui/consts/uninhabited-const-issue-61744.stderr
@@ -659,6 +659,6 @@ LL |     dbg!(i32::CONSTANT);
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/unstable-const-fn-in-libcore.stderr b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
index b75f99a720f..4b649bf43ed 100644
--- a/tests/ui/consts/unstable-const-fn-in-libcore.stderr
+++ b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL |     const fn unwrap_or_else<F: ~const FnOnce() -> T>(self, f: F) -> T {
    |                                       ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/copy-a-resource.stderr b/tests/ui/copy-a-resource.stderr
index 128087f1e37..ff1e28bf961 100644
--- a/tests/ui/copy-a-resource.stderr
+++ b/tests/ui/copy-a-resource.stderr
@@ -11,6 +11,6 @@ LL |     let _y = x.clone();
    = note: the following trait defines an item `clone`, perhaps you need to implement it:
            candidate #1: `Clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/coroutine/async-coroutine-issue-67158.stderr b/tests/ui/coroutine/async-coroutine-issue-67158.stderr
index d583d3d5ea0..1c4a6b0c355 100644
--- a/tests/ui/coroutine/async-coroutine-issue-67158.stderr
+++ b/tests/ui/coroutine/async-coroutine-issue-67158.stderr
@@ -4,6 +4,6 @@ error[E0727]: `async` coroutines are not yet supported
 LL |     async { yield print!(":C") };
    |             ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0727`.
diff --git a/tests/ui/coroutine/coroutine-region-requirements.stderr b/tests/ui/coroutine/coroutine-region-requirements.stderr
index ad3183e7612..d31b4eb2b3c 100644
--- a/tests/ui/coroutine/coroutine-region-requirements.stderr
+++ b/tests/ui/coroutine/coroutine-region-requirements.stderr
@@ -7,5 +7,5 @@ LL | fn dangle(x: &mut i32) -> &'static mut i32 {
 LL |             CoroutineState::Complete(c) => return c,
    |                                                   ^ returning this value requires that `'1` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coroutine/coroutine-with-nll.stderr b/tests/ui/coroutine/coroutine-with-nll.stderr
index ed58debe2b4..77e8bb1f92e 100644
--- a/tests/ui/coroutine/coroutine-with-nll.stderr
+++ b/tests/ui/coroutine/coroutine-with-nll.stderr
@@ -7,6 +7,6 @@ LL |
 LL |         yield ();
    |         -------- possible yield occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0626`.
diff --git a/tests/ui/coroutine/drop-yield-twice.stderr b/tests/ui/coroutine/drop-yield-twice.stderr
index fbbedac5775..b37c27015fb 100644
--- a/tests/ui/coroutine/drop-yield-twice.stderr
+++ b/tests/ui/coroutine/drop-yield-twice.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `assert_send`
 LL | fn assert_send<T: Send>(_: T) {}
    |                   ^^^^ required by this bound in `assert_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coroutine/dropck-resume.stderr b/tests/ui/coroutine/dropck-resume.stderr
index 028523978f9..aa6e423c760 100644
--- a/tests/ui/coroutine/dropck-resume.stderr
+++ b/tests/ui/coroutine/dropck-resume.stderr
@@ -10,6 +10,6 @@ LL |
 LL |     }
    |     - mutable borrow might be used here, when `g` is dropped and runs the destructor for coroutine
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/coroutine/gen_block_is_no_future.stderr b/tests/ui/coroutine/gen_block_is_no_future.stderr
index db0c3c19b58..f9e23e45b44 100644
--- a/tests/ui/coroutine/gen_block_is_no_future.stderr
+++ b/tests/ui/coroutine/gen_block_is_no_future.stderr
@@ -7,6 +7,6 @@ LL | fn foo() -> impl std::future::Future {
    = help: the trait `Future` is not implemented for `{gen block@$DIR/gen_block_is_no_future.rs:5:5: 5:21}`
    = note: {gen block@$DIR/gen_block_is_no_future.rs:5:5: 5:21} must be a future or must implement `IntoFuture` to be awaited
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/gen_block_move.stderr b/tests/ui/coroutine/gen_block_move.stderr
index b93ac65f5e7..b93f6a9a610 100644
--- a/tests/ui/coroutine/gen_block_move.stderr
+++ b/tests/ui/coroutine/gen_block_move.stderr
@@ -25,6 +25,6 @@ help: to force the gen block to take ownership of `x` (and any other referenced
 LL |     gen move {
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/coroutine/gen_fn.e2024.stderr b/tests/ui/coroutine/gen_fn.e2024.stderr
index 388e10fd65e..928c16f57a2 100644
--- a/tests/ui/coroutine/gen_fn.e2024.stderr
+++ b/tests/ui/coroutine/gen_fn.e2024.stderr
@@ -6,5 +6,5 @@ LL | gen fn foo() {}
    |
    = help: for now you can use `gen {}` blocks and return `impl Iterator` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coroutine/gen_fn.none.stderr b/tests/ui/coroutine/gen_fn.none.stderr
index 5e7bd9d8bbf..c5342ee22e6 100644
--- a/tests/ui/coroutine/gen_fn.none.stderr
+++ b/tests/ui/coroutine/gen_fn.none.stderr
@@ -4,5 +4,5 @@ error: expected one of `#`, `async`, `const`, `default`, `extern`, `fn`, `pub`,
 LL | gen fn foo() {}
    | ^^^ expected one of 9 possible tokens
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coroutine/issue-102645.stderr b/tests/ui/coroutine/issue-102645.stderr
index 3db090346cd..7a3b7f2b04c 100644
--- a/tests/ui/coroutine/issue-102645.stderr
+++ b/tests/ui/coroutine/issue-102645.stderr
@@ -11,6 +11,6 @@ help: provide the argument
 LL |     Pin::new(&mut b).resume(());
    |                            ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.mir.stderr b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.mir.stderr
index a9a0d629606..11dc57bcf46 100644
--- a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.mir.stderr
+++ b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.mir.stderr
@@ -6,6 +6,6 @@ LL |         *(1 as *mut u32) = 42;
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.thir.stderr b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.thir.stderr
index 22c83e9a3d5..a61689a0df5 100644
--- a/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.thir.stderr
+++ b/tests/ui/coroutine/issue-45729-unsafe-in-coroutine.thir.stderr
@@ -6,6 +6,6 @@ LL |         *(1 as *mut u32) = 42;
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/coroutine/issue-48048.stderr b/tests/ui/coroutine/issue-48048.stderr
index bb9f189fa7c..199ecf4ca6a 100644
--- a/tests/ui/coroutine/issue-48048.stderr
+++ b/tests/ui/coroutine/issue-48048.stderr
@@ -6,6 +6,6 @@ LL |         x.0({
 LL |             yield;
    |             ----- possible yield occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0626`.
diff --git a/tests/ui/coroutine/issue-64620-yield-array-element.stderr b/tests/ui/coroutine/issue-64620-yield-array-element.stderr
index 47632d083ea..347532fb719 100644
--- a/tests/ui/coroutine/issue-64620-yield-array-element.stderr
+++ b/tests/ui/coroutine/issue-64620-yield-array-element.stderr
@@ -4,6 +4,6 @@ error[E0627]: yield expression outside of coroutine literal
 LL |     yield arr[0];
    |     ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/issue-88653.stderr b/tests/ui/coroutine/issue-88653.stderr
index 3ae50b5aff2..8a23ad17b8b 100644
--- a/tests/ui/coroutine/issue-88653.stderr
+++ b/tests/ui/coroutine/issue-88653.stderr
@@ -10,6 +10,6 @@ LL |     |bar| {
    = note: expected coroutine signature `fn((bool,)) -> _`
               found coroutine signature `fn(bool) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/coroutine/issue-91477.stderr b/tests/ui/coroutine/issue-91477.stderr
index 0ab3c1fbabc..ca8e43d8a26 100644
--- a/tests/ui/coroutine/issue-91477.stderr
+++ b/tests/ui/coroutine/issue-91477.stderr
@@ -4,6 +4,6 @@ error[E0627]: yield expression outside of coroutine literal
 LL |     yield 1;
    |     ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/layout-error.stderr b/tests/ui/coroutine/layout-error.stderr
index b1a258f4f2c..249a99e9b85 100644
--- a/tests/ui/coroutine/layout-error.stderr
+++ b/tests/ui/coroutine/layout-error.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `Foo` in this scope
 LL |         let a = Foo;
    |                 ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/coroutine/metadata-sufficient-for-layout.stderr b/tests/ui/coroutine/metadata-sufficient-for-layout.stderr
index 3488b04f226..c7860fde2a9 100644
--- a/tests/ui/coroutine/metadata-sufficient-for-layout.stderr
+++ b/tests/ui/coroutine/metadata-sufficient-for-layout.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/coroutine/pattern-borrow.stderr b/tests/ui/coroutine/pattern-borrow.stderr
index ddb3bf66214..9e7b330d79d 100644
--- a/tests/ui/coroutine/pattern-borrow.stderr
+++ b/tests/ui/coroutine/pattern-borrow.stderr
@@ -6,6 +6,6 @@ LL |         if let Test::A(ref _a) = test {
 LL |             yield ();
    |             -------- possible yield occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0626`.
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
index fb80f29d10d..100993bd33c 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
@@ -14,6 +14,6 @@ LL | |     };
    = note: expected unit type `()`
               found coroutine `{main::{closure#0} upvar_tys=(unavailable)}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr b/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr
index 4c8694e6786..8811faf2fad 100644
--- a/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr
+++ b/tests/ui/coroutine/ref-escapes-but-not-over-yield.stderr
@@ -10,6 +10,6 @@ LL |         a = &b;
    |         |   borrow is only valid in the coroutine body
    |         reference to `b` escapes the coroutine body here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/coroutine/resume-arg-late-bound.stderr b/tests/ui/coroutine/resume-arg-late-bound.stderr
index f1a8a8ed711..a97cc6190fd 100644
--- a/tests/ui/coroutine/resume-arg-late-bound.stderr
+++ b/tests/ui/coroutine/resume-arg-late-bound.stderr
@@ -12,6 +12,6 @@ note: the lifetime requirement is introduced here
 LL | fn test(a: impl for<'a> Coroutine<&'a mut bool>) {}
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coroutine/retain-resume-ref.stderr b/tests/ui/coroutine/retain-resume-ref.stderr
index e33310d12d9..eb8b78df6c9 100644
--- a/tests/ui/coroutine/retain-resume-ref.stderr
+++ b/tests/ui/coroutine/retain-resume-ref.stderr
@@ -8,6 +8,6 @@ LL |     gen.as_mut().resume(&mut thing);
    |                  |
    |                  first borrow later used by call
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/coroutine/self_referential_gen_block.stderr b/tests/ui/coroutine/self_referential_gen_block.stderr
index 586f53df8f2..e23d653d0d4 100644
--- a/tests/ui/coroutine/self_referential_gen_block.stderr
+++ b/tests/ui/coroutine/self_referential_gen_block.stderr
@@ -6,6 +6,6 @@ LL |             let z = &y;
 LL |             yield 43;
    |             -------- possible yield occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0626`.
diff --git a/tests/ui/coroutine/static-not-unpin.current.stderr b/tests/ui/coroutine/static-not-unpin.current.stderr
index cd607904f5a..8ef54298431 100644
--- a/tests/ui/coroutine/static-not-unpin.current.stderr
+++ b/tests/ui/coroutine/static-not-unpin.current.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `assert_unpin`
 LL | fn assert_unpin<T: Unpin>(_: T) {
    |                    ^^^^^ required by this bound in `assert_unpin`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/static-not-unpin.next.stderr b/tests/ui/coroutine/static-not-unpin.next.stderr
index cd607904f5a..8ef54298431 100644
--- a/tests/ui/coroutine/static-not-unpin.next.stderr
+++ b/tests/ui/coroutine/static-not-unpin.next.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `assert_unpin`
 LL | fn assert_unpin<T: Unpin>(_: T) {
    |                    ^^^^^ required by this bound in `assert_unpin`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/too-many-parameters.stderr b/tests/ui/coroutine/too-many-parameters.stderr
index 54cf42e78d3..c0917c7225b 100644
--- a/tests/ui/coroutine/too-many-parameters.stderr
+++ b/tests/ui/coroutine/too-many-parameters.stderr
@@ -4,6 +4,6 @@ error[E0628]: too many parameters for a coroutine (expected 0 or 1 parameters)
 LL |     |(), ()| {
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0628`.
diff --git a/tests/ui/coroutine/type-mismatch-error.stderr b/tests/ui/coroutine/type-mismatch-error.stderr
index 8f5949533e2..737d9afdd79 100644
--- a/tests/ui/coroutine/type-mismatch-error.stderr
+++ b/tests/ui/coroutine/type-mismatch-error.stderr
@@ -14,6 +14,6 @@ LL | |
 LL | |             }
    | |_____________- `if` and `else` have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/coroutine/unresolved-ct-var.stderr b/tests/ui/coroutine/unresolved-ct-var.stderr
index 9badc1dc291..da2ec272f9f 100644
--- a/tests/ui/coroutine/unresolved-ct-var.stderr
+++ b/tests/ui/coroutine/unresolved-ct-var.stderr
@@ -12,6 +12,6 @@ LL |         let s = std::array::from_fn(|_| ()).await;
    = note: [(); _] must be a future or must implement `IntoFuture` to be awaited
    = note: required for `[(); _]` to implement `IntoFuture`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/unsized-capture-across-yield.stderr b/tests/ui/coroutine/unsized-capture-across-yield.stderr
index 8a5b968a561..436f0901a97 100644
--- a/tests/ui/coroutine/unsized-capture-across-yield.stderr
+++ b/tests/ui/coroutine/unsized-capture-across-yield.stderr
@@ -18,6 +18,6 @@ LL |         println!("{:?}", &b);
    = help: the trait `Sized` is not implemented for `[u8]`
    = note: all values captured by value by a closure must have a statically known size
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/unsized-local-across-yield.stderr b/tests/ui/coroutine/unsized-local-across-yield.stderr
index 1942f266e6c..c4c3be77ac2 100644
--- a/tests/ui/coroutine/unsized-local-across-yield.stderr
+++ b/tests/ui/coroutine/unsized-local-across-yield.stderr
@@ -16,6 +16,6 @@ LL |         let b: [u8] = *(Box::new([]) as Box<[u8]>);
    = help: the trait `Sized` is not implemented for `[u8]`
    = note: all values live across `yield` must have a statically known size
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/yield-in-args.stderr b/tests/ui/coroutine/yield-in-args.stderr
index 4ff97281d7b..7233f47884b 100644
--- a/tests/ui/coroutine/yield-in-args.stderr
+++ b/tests/ui/coroutine/yield-in-args.stderr
@@ -4,6 +4,6 @@ error[E0626]: borrow may still be in use when coroutine yields
 LL |         foo(&b, yield);
    |             ^^  ----- possible yield occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0626`.
diff --git a/tests/ui/coroutine/yield-in-const.stderr b/tests/ui/coroutine/yield-in-const.stderr
index 7afcd83403e..d5748b05337 100644
--- a/tests/ui/coroutine/yield-in-const.stderr
+++ b/tests/ui/coroutine/yield-in-const.stderr
@@ -4,6 +4,6 @@ error[E0627]: yield expression outside of coroutine literal
 LL | const A: u8 = { yield 3u8; 3u8};
    |                 ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/yield-in-function.stderr b/tests/ui/coroutine/yield-in-function.stderr
index b2f839a65db..b9d4708bb8d 100644
--- a/tests/ui/coroutine/yield-in-function.stderr
+++ b/tests/ui/coroutine/yield-in-function.stderr
@@ -4,6 +4,6 @@ error[E0627]: yield expression outside of coroutine literal
 LL | fn main() { yield; }
    |             ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/yield-in-static.stderr b/tests/ui/coroutine/yield-in-static.stderr
index 17d58325e98..b56283cab66 100644
--- a/tests/ui/coroutine/yield-in-static.stderr
+++ b/tests/ui/coroutine/yield-in-static.stderr
@@ -4,6 +4,6 @@ error[E0627]: yield expression outside of coroutine literal
 LL | static B: u8 = { yield 3u8; 3u8};
    |                  ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0627`.
diff --git a/tests/ui/coroutine/yield-while-ref-reborrowed.stderr b/tests/ui/coroutine/yield-while-ref-reborrowed.stderr
index e60a9531622..62ac0265311 100644
--- a/tests/ui/coroutine/yield-while-ref-reborrowed.stderr
+++ b/tests/ui/coroutine/yield-while-ref-reborrowed.stderr
@@ -13,6 +13,6 @@ LL |     Pin::new(&mut b).resume(());
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0501`.
diff --git a/tests/ui/crate-loading/crateresolve1.stderr b/tests/ui/crate-loading/crateresolve1.stderr
index 7b840b52628..47131a96bf4 100644
--- a/tests/ui/crate-loading/crateresolve1.stderr
+++ b/tests/ui/crate-loading/crateresolve1.stderr
@@ -8,6 +8,6 @@ LL | extern crate crateresolve1;
    = note: candidate #2: $TEST_BUILD_DIR/crate-loading/crateresolve1/auxiliary/libcrateresolve1-2.somelib
    = note: candidate #3: $TEST_BUILD_DIR/crate-loading/crateresolve1/auxiliary/libcrateresolve1-3.somelib
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0464`.
diff --git a/tests/ui/crate-loading/crateresolve2.stderr b/tests/ui/crate-loading/crateresolve2.stderr
index a36f4f02265..3dc89dabde6 100644
--- a/tests/ui/crate-loading/crateresolve2.stderr
+++ b/tests/ui/crate-loading/crateresolve2.stderr
@@ -8,6 +8,6 @@ LL | extern crate crateresolve2;
    = note: candidate #2: $TEST_BUILD_DIR/crate-loading/crateresolve2/auxiliary/libcrateresolve2-2.rmeta
    = note: candidate #3: $TEST_BUILD_DIR/crate-loading/crateresolve2/auxiliary/libcrateresolve2-3.rmeta
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0464`.
diff --git a/tests/ui/crate-name-mismatch.stderr b/tests/ui/crate-name-mismatch.stderr
index 96618570d8f..511562618d5 100644
--- a/tests/ui/crate-name-mismatch.stderr
+++ b/tests/ui/crate-name-mismatch.stderr
@@ -4,5 +4,5 @@ error: `--crate-name` and `#[crate_name]` are required to match, but `foo` != `b
 LL | #![crate_name = "bar"]
    | ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/cross/cross-borrow-trait.stderr b/tests/ui/cross/cross-borrow-trait.stderr
index 4f5af106613..b670de39f6d 100644
--- a/tests/ui/cross/cross-borrow-trait.stderr
+++ b/tests/ui/cross/cross-borrow-trait.stderr
@@ -9,6 +9,6 @@ LL |     let _y: &dyn Trait = x;
    = note: expected reference `&dyn Trait`
                  found struct `Box<dyn Trait>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/cross/cross-crate-macro-backtrace/main.stderr b/tests/ui/cross/cross-crate-macro-backtrace/main.stderr
index 5bd4ea97e9c..d6f20b1f8e9 100644
--- a/tests/ui/cross/cross-crate-macro-backtrace/main.stderr
+++ b/tests/ui/cross/cross-crate-macro-backtrace/main.stderr
@@ -6,5 +6,5 @@ LL |     myprintln!("{}");
    |
    = note: this error originates in the macro `concat` which comes from the expansion of the macro `myprintln` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/cross/cross-file-errors/main.stderr b/tests/ui/cross/cross-file-errors/main.stderr
index 56eb6ad429a..c7dea801acf 100644
--- a/tests/ui/cross/cross-file-errors/main.stderr
+++ b/tests/ui/cross/cross-file-errors/main.stderr
@@ -11,5 +11,5 @@ LL |     underscore!();
    |
    = note: this error originates in the macro `underscore` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/cross/cross-fn-cache-hole.stderr b/tests/ui/cross/cross-fn-cache-hole.stderr
index 79d1713934b..ae944387f57 100644
--- a/tests/ui/cross/cross-fn-cache-hole.stderr
+++ b/tests/ui/cross/cross-fn-cache-hole.stderr
@@ -12,6 +12,6 @@ LL | trait Bar<X> { }
    = help: see issue #48214
    = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/custom-attribute-multisegment.stderr b/tests/ui/custom-attribute-multisegment.stderr
index 57eca211ed1..90ebe277939 100644
--- a/tests/ui/custom-attribute-multisegment.stderr
+++ b/tests/ui/custom-attribute-multisegment.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: could not find `nonexistent` in `existent`
 LL | #[existent::nonexistent]
    |             ^^^^^^^^^^^ could not find `nonexistent` in `existent`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/custom_test_frameworks/mismatch.stderr b/tests/ui/custom_test_frameworks/mismatch.stderr
index 31b18b2df98..dad93cfbba4 100644
--- a/tests/ui/custom_test_frameworks/mismatch.stderr
+++ b/tests/ui/custom_test_frameworks/mismatch.stderr
@@ -9,6 +9,6 @@ LL | fn wrong_kind(){}
    = note: required for the cast from `&TestDescAndFn` to `&dyn Testable`
    = note: this error originates in the attribute macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/cycle-trait/cycle-trait-default-type-trait.stderr b/tests/ui/cycle-trait/cycle-trait-default-type-trait.stderr
index 3b66704d613..e8be9b0b913 100644
--- a/tests/ui/cycle-trait/cycle-trait-default-type-trait.stderr
+++ b/tests/ui/cycle-trait/cycle-trait-default-type-trait.stderr
@@ -16,6 +16,6 @@ LL | | fn main() { }
    | |_____________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/cycle-trait/cycle-trait-supertrait-direct.stderr b/tests/ui/cycle-trait/cycle-trait-supertrait-direct.stderr
index 03cb5015ab0..8645b4ebccf 100644
--- a/tests/ui/cycle-trait/cycle-trait-supertrait-direct.stderr
+++ b/tests/ui/cycle-trait/cycle-trait-supertrait-direct.stderr
@@ -14,6 +14,6 @@ LL | | }
    | |_^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.stderr b/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.stderr
index c7cc3143520..f2d8f07b04e 100644
--- a/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.stderr
+++ b/tests/ui/cycle-trait/cycle-trait-supertrait-indirect.stderr
@@ -17,6 +17,6 @@ LL | trait A: B {
    |          ^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/cycle-trait/issue-12511.stderr b/tests/ui/cycle-trait/issue-12511.stderr
index f5e4f83473d..bc56b9904f5 100644
--- a/tests/ui/cycle-trait/issue-12511.stderr
+++ b/tests/ui/cycle-trait/issue-12511.stderr
@@ -19,6 +19,6 @@ LL | | }
    | |_^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.stderr b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.stderr
index d5991bcf569..06aad9616cb 100644
--- a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.stderr
+++ b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-1.stderr
@@ -1,4 +1,4 @@
 error: values of the type `[u8; usize::MAX]` are too big for the current architecture
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.stderr b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.stderr
index d5991bcf569..06aad9616cb 100644
--- a/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.stderr
+++ b/tests/ui/debuginfo/debuginfo-type-name-layout-ice-94961-2.stderr
@@ -1,4 +1,4 @@
 error: values of the type `[u8; usize::MAX]` are too big for the current architecture
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr
index cdc268cff99..f26b43aa3ec 100644
--- a/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr
+++ b/tests/ui/dep-graph/dep-graph-assoc-type-codegen.stderr
@@ -4,5 +4,5 @@ error: OK
 LL |     #[rustc_then_this_would_need(typeck)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/dep-graph/dep-graph-variance-alias.stderr b/tests/ui/dep-graph/dep-graph-variance-alias.stderr
index 554ff455a20..e11de245289 100644
--- a/tests/ui/dep-graph/dep-graph-variance-alias.stderr
+++ b/tests/ui/dep-graph/dep-graph-variance-alias.stderr
@@ -4,5 +4,5 @@ error: OK
 LL | #[rustc_then_this_would_need(variances_of)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/deprecation/deprecated_no_stack_check.stderr b/tests/ui/deprecation/deprecated_no_stack_check.stderr
index 141664c1092..d78ca20f10b 100644
--- a/tests/ui/deprecation/deprecated_no_stack_check.stderr
+++ b/tests/ui/deprecation/deprecated_no_stack_check.stderr
@@ -4,6 +4,6 @@ error[E0557]: feature has been removed
 LL | #![feature(no_stack_check)]
    |            ^^^^^^^^^^^^^^ feature has been removed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0557`.
diff --git a/tests/ui/deprecation/deprecation-lint-2.stderr b/tests/ui/deprecation/deprecation-lint-2.stderr
index a73e5605271..7d411c00445 100644
--- a/tests/ui/deprecation/deprecation-lint-2.stderr
+++ b/tests/ui/deprecation/deprecation-lint-2.stderr
@@ -11,5 +11,5 @@ LL | #![deny(deprecated)]
    |         ^^^^^^^^^^
    = note: this error originates in the macro `macro_test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/deprecation/deprecation-lint-3.stderr b/tests/ui/deprecation/deprecation-lint-3.stderr
index f499ff85e5d..1723b7bbd05 100644
--- a/tests/ui/deprecation/deprecation-lint-3.stderr
+++ b/tests/ui/deprecation/deprecation-lint-3.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(deprecated)]
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/deprecation/feature-gate-deprecated_suggestion.stderr b/tests/ui/deprecation/feature-gate-deprecated_suggestion.stderr
index 438ce3349d2..81cc608b5eb 100644
--- a/tests/ui/deprecation/feature-gate-deprecated_suggestion.stderr
+++ b/tests/ui/deprecation/feature-gate-deprecated_suggestion.stderr
@@ -7,5 +7,5 @@ LL | #[deprecated(suggestion = "foo")]
    = help: add `#![feature(deprecated_suggestion)]` to the crate root
    = note: see #94785 for more details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/deprecation/invalid-literal.stderr b/tests/ui/deprecation/invalid-literal.stderr
index b56eedeb80d..ca827beda05 100644
--- a/tests/ui/deprecation/invalid-literal.stderr
+++ b/tests/ui/deprecation/invalid-literal.stderr
@@ -13,5 +13,5 @@ LL | #[deprecated(/*opt*/ since = "version", /*opt*/ note = "reason")]
 LL | #[deprecated]
    | ~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
index 24178faf8de..48c763c50e3 100644
--- a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
+++ b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
@@ -4,5 +4,5 @@ error: expected unsuffixed literal or identifier, found `test`
 LL | #[deprecated(note = test)]
    |                     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/deref-non-pointer.stderr b/tests/ui/deref-non-pointer.stderr
index 1297e496bcb..2e5e574fb6c 100644
--- a/tests/ui/deref-non-pointer.stderr
+++ b/tests/ui/deref-non-pointer.stderr
@@ -4,6 +4,6 @@ error[E0614]: type `{integer}` cannot be dereferenced
 LL |   match *1 {
    |         ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0614`.
diff --git a/tests/ui/deref-patterns/gate.stderr b/tests/ui/deref-patterns/gate.stderr
index b5b79ed3771..e3cbded339d 100644
--- a/tests/ui/deref-patterns/gate.stderr
+++ b/tests/ui/deref-patterns/gate.stderr
@@ -6,6 +6,6 @@ LL |     match String::new() {
 LL |         "" | _ => {}
    |         ^^ expected `String`, found `&str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/derived-errors/issue-30580.stderr b/tests/ui/derived-errors/issue-30580.stderr
index 4e60368c387..05b55591729 100644
--- a/tests/ui/derived-errors/issue-30580.stderr
+++ b/tests/ui/derived-errors/issue-30580.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |         b.a;
    |           ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/derived-errors/issue-31997-1.stderr b/tests/ui/derived-errors/issue-31997-1.stderr
index a0262f4c1e5..40485027a66 100644
--- a/tests/ui/derived-errors/issue-31997-1.stderr
+++ b/tests/ui/derived-errors/issue-31997-1.stderr
@@ -9,6 +9,6 @@ help: consider importing this struct
 LL + use std::collections::HashMap;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/derived-errors/issue-31997.stderr b/tests/ui/derived-errors/issue-31997.stderr
index b53c0cda8de..7d6415fef83 100644
--- a/tests/ui/derived-errors/issue-31997.stderr
+++ b/tests/ui/derived-errors/issue-31997.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `bar` in this scope
 LL |     try!(closure(|| bar(core::ptr::null_mut())));
    |                     ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/derives/clone-debug-dead-code-in-the-same-struct.stderr b/tests/ui/derives/clone-debug-dead-code-in-the-same-struct.stderr
index 7f4f78cebc9..e9b757b6bae 100644
--- a/tests/ui/derives/clone-debug-dead-code-in-the-same-struct.stderr
+++ b/tests/ui/derives/clone-debug-dead-code-in-the-same-struct.stderr
@@ -20,5 +20,5 @@ note: the lint level is defined here
 LL | #![forbid(dead_code)]
    |           ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/derives/derive-assoc-type-not-impl.stderr b/tests/ui/derives/derive-assoc-type-not-impl.stderr
index 9f17c76c2ec..6cbcb455f87 100644
--- a/tests/ui/derives/derive-assoc-type-not-impl.stderr
+++ b/tests/ui/derives/derive-assoc-type-not-impl.stderr
@@ -27,6 +27,6 @@ LL + #[derive(Clone)]
 LL | struct NotClone;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/derives/derive-deadlock.stderr b/tests/ui/derives/derive-deadlock.stderr
index 8d062491c6a..116245aa3cb 100644
--- a/tests/ui/derives/derive-deadlock.stderr
+++ b/tests/ui/derives/derive-deadlock.stderr
@@ -6,5 +6,5 @@ LL | #[derive(Default)]
    |
    = note: import resolution is stuck, try simplifying macro imports
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr
index 31ab589cf38..2c8d9431646 100644
--- a/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-Clone-enum-struct-variant.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Clone)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone-enum.stderr b/tests/ui/derives/derives-span-Clone-enum.stderr
index b5580c02f38..b683a8b8944 100644
--- a/tests/ui/derives/derives-span-Clone-enum.stderr
+++ b/tests/ui/derives/derives-span-Clone-enum.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Clone)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone-struct.stderr b/tests/ui/derives/derives-span-Clone-struct.stderr
index fbe7e3f8479..305a9275271 100644
--- a/tests/ui/derives/derives-span-Clone-struct.stderr
+++ b/tests/ui/derives/derives-span-Clone-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Clone)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Clone-tuple-struct.stderr b/tests/ui/derives/derives-span-Clone-tuple-struct.stderr
index 639f4d54254..b636404ad9e 100644
--- a/tests/ui/derives/derives-span-Clone-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-Clone-tuple-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Clone)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr
index 7ff6851f655..3f6c39bf939 100644
--- a/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-Debug-enum-struct-variant.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Debug)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-enum.stderr b/tests/ui/derives/derives-span-Debug-enum.stderr
index 346cbec90a9..eaeffaeb849 100644
--- a/tests/ui/derives/derives-span-Debug-enum.stderr
+++ b/tests/ui/derives/derives-span-Debug-enum.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Debug)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-struct.stderr b/tests/ui/derives/derives-span-Debug-struct.stderr
index 4b39eeb09ee..4a725e260de 100644
--- a/tests/ui/derives/derives-span-Debug-struct.stderr
+++ b/tests/ui/derives/derives-span-Debug-struct.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Debug)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Debug-tuple-struct.stderr b/tests/ui/derives/derives-span-Debug-tuple-struct.stderr
index f3043abcadd..2f816e1c85b 100644
--- a/tests/ui/derives/derives-span-Debug-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-Debug-tuple-struct.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Debug)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Default-struct.stderr b/tests/ui/derives/derives-span-Default-struct.stderr
index 4844b635924..359b61528e1 100644
--- a/tests/ui/derives/derives-span-Default-struct.stderr
+++ b/tests/ui/derives/derives-span-Default-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Default)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Default-tuple-struct.stderr b/tests/ui/derives/derives-span-Default-tuple-struct.stderr
index 9cac7f10780..1ddb4ec3f64 100644
--- a/tests/ui/derives/derives-span-Default-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-Default-tuple-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Default)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr
index 1a9ff983255..c9edc89e1bc 100644
--- a/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-Eq-enum-struct-variant.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Eq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-enum.stderr b/tests/ui/derives/derives-span-Eq-enum.stderr
index 8205657bb71..7db13e97111 100644
--- a/tests/ui/derives/derives-span-Eq-enum.stderr
+++ b/tests/ui/derives/derives-span-Eq-enum.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Eq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-struct.stderr b/tests/ui/derives/derives-span-Eq-struct.stderr
index af510181df7..36eeb89bde1 100644
--- a/tests/ui/derives/derives-span-Eq-struct.stderr
+++ b/tests/ui/derives/derives-span-Eq-struct.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Eq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Eq-tuple-struct.stderr b/tests/ui/derives/derives-span-Eq-tuple-struct.stderr
index f7c371d7d05..126d1053540 100644
--- a/tests/ui/derives/derives-span-Eq-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-Eq-tuple-struct.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Eq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr
index 311edade0f3..ae973228cac 100644
--- a/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-Hash-enum-struct-variant.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Hash)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-enum.stderr b/tests/ui/derives/derives-span-Hash-enum.stderr
index 043aa954bfa..85e26c84fa7 100644
--- a/tests/ui/derives/derives-span-Hash-enum.stderr
+++ b/tests/ui/derives/derives-span-Hash-enum.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Hash)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-struct.stderr b/tests/ui/derives/derives-span-Hash-struct.stderr
index 26d31b6613f..f9a654b2df7 100644
--- a/tests/ui/derives/derives-span-Hash-struct.stderr
+++ b/tests/ui/derives/derives-span-Hash-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Hash)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Hash-tuple-struct.stderr b/tests/ui/derives/derives-span-Hash-tuple-struct.stderr
index 3155a023ce8..0a5fbe28658 100644
--- a/tests/ui/derives/derives-span-Hash-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-Hash-tuple-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Hash)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr b/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr
index 1a06aee5235..96ef59ca963 100644
--- a/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-Ord-enum-struct-variant.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Ord)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-enum.stderr b/tests/ui/derives/derives-span-Ord-enum.stderr
index 377728e8a7f..7c75ecb6432 100644
--- a/tests/ui/derives/derives-span-Ord-enum.stderr
+++ b/tests/ui/derives/derives-span-Ord-enum.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Ord)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-struct.stderr b/tests/ui/derives/derives-span-Ord-struct.stderr
index e00e990da2a..429e7e06f5d 100644
--- a/tests/ui/derives/derives-span-Ord-struct.stderr
+++ b/tests/ui/derives/derives-span-Ord-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Ord)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-Ord-tuple-struct.stderr b/tests/ui/derives/derives-span-Ord-tuple-struct.stderr
index 959d0b96404..a46133834c6 100644
--- a/tests/ui/derives/derives-span-Ord-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-Ord-tuple-struct.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Ord)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr b/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
index e3b17431f89..d0b14ef94c1 100644
--- a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
@@ -19,6 +19,6 @@ LL + #[derive(PartialEq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq-enum.stderr b/tests/ui/derives/derives-span-PartialEq-enum.stderr
index d1631732a34..f69451ac793 100644
--- a/tests/ui/derives/derives-span-PartialEq-enum.stderr
+++ b/tests/ui/derives/derives-span-PartialEq-enum.stderr
@@ -19,6 +19,6 @@ LL + #[derive(PartialEq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq-struct.stderr b/tests/ui/derives/derives-span-PartialEq-struct.stderr
index ab6c6951fc6..d7fc3da46e0 100644
--- a/tests/ui/derives/derives-span-PartialEq-struct.stderr
+++ b/tests/ui/derives/derives-span-PartialEq-struct.stderr
@@ -19,6 +19,6 @@ LL + #[derive(PartialEq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr b/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
index 865ecad0e8e..ea3920f406c 100644
--- a/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-PartialEq-tuple-struct.stderr
@@ -19,6 +19,6 @@ LL + #[derive(PartialEq)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr b/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr
index 746c1d5d21f..3f83eb56aaf 100644
--- a/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-PartialOrd-enum-struct-variant.stderr
@@ -15,6 +15,6 @@ LL + #[derive(PartialOrd)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-enum.stderr b/tests/ui/derives/derives-span-PartialOrd-enum.stderr
index 8af1776dac8..cf5915173c5 100644
--- a/tests/ui/derives/derives-span-PartialOrd-enum.stderr
+++ b/tests/ui/derives/derives-span-PartialOrd-enum.stderr
@@ -15,6 +15,6 @@ LL + #[derive(PartialOrd)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-struct.stderr b/tests/ui/derives/derives-span-PartialOrd-struct.stderr
index 11ea7f9dc31..de21a903b6c 100644
--- a/tests/ui/derives/derives-span-PartialOrd-struct.stderr
+++ b/tests/ui/derives/derives-span-PartialOrd-struct.stderr
@@ -15,6 +15,6 @@ LL + #[derive(PartialOrd)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr b/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr
index 0a41a3db31e..3050aeecc0d 100644
--- a/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr
+++ b/tests/ui/derives/derives-span-PartialOrd-tuple-struct.stderr
@@ -15,6 +15,6 @@ LL + #[derive(PartialOrd)]
 LL | struct Error;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/derives/deriving-with-repr-packed-2.stderr b/tests/ui/derives/deriving-with-repr-packed-2.stderr
index afeca9fec2b..0eaca7e2360 100644
--- a/tests/ui/derives/deriving-with-repr-packed-2.stderr
+++ b/tests/ui/derives/deriving-with-repr-packed-2.stderr
@@ -29,6 +29,6 @@ LL + #[derive(Clone, Copy)]
 LL | struct NonCopy;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/derives/deriving-with-repr-packed.stderr b/tests/ui/derives/deriving-with-repr-packed.stderr
index bb1fab343a3..151be6901b0 100644
--- a/tests/ui/derives/deriving-with-repr-packed.stderr
+++ b/tests/ui/derives/deriving-with-repr-packed.stderr
@@ -39,7 +39,7 @@ LL | struct X(Y);
    = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
    = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error; 2 warnings emitted
+error: aborting due to 1 previous error; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0507`.
 Future incompatibility report: Future breakage diagnostic:
diff --git a/tests/ui/derives/issue-97343.stderr b/tests/ui/derives/issue-97343.stderr
index e83bbb5b60d..efb2fb70f5a 100644
--- a/tests/ui/derives/issue-97343.stderr
+++ b/tests/ui/derives/issue-97343.stderr
@@ -16,6 +16,6 @@ LL | pub struct Irrelevant<Irrelevant> {
    |                       ^^^^^^^^^^
    = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/deriving/issue-103157.stderr b/tests/ui/deriving/issue-103157.stderr
index 01cce2a397a..384899ea433 100644
--- a/tests/ui/deriving/issue-103157.stderr
+++ b/tests/ui/deriving/issue-103157.stderr
@@ -22,6 +22,6 @@ note: required by a bound in `AssertParamIsEq`
   --> $SRC_DIR/core/src/cmp.rs:LL:COL
    = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/destructuring-assignment/default-match-bindings-forbidden.stderr b/tests/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
index b285ee1f304..b0231d91b43 100644
--- a/tests/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
+++ b/tests/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
@@ -9,6 +9,6 @@ LL |     (x, y) = &(1, 2);
    = note: expected reference `&({integer}, {integer})`
                   found tuple `(_, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-flags/terminal_urls.stderr b/tests/ui/diagnostic-flags/terminal_urls.stderr
index 7f7e69c5d5d..e5dfcdf6431 100644
--- a/tests/ui/diagnostic-flags/terminal_urls.stderr
+++ b/tests/ui/diagnostic-flags/terminal_urls.stderr
@@ -6,6 +6,6 @@ LL |     let () = 4;
    |         |
    |         expected integer, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/E0271.stderr b/tests/ui/diagnostic-width/E0271.stderr
index c1b8b32071c..31ec3fe366f 100644
--- a/tests/ui/diagnostic-width/E0271.stderr
+++ b/tests/ui/diagnostic-width/E0271.stderr
@@ -17,6 +17,6 @@ LL |     type Error = E;
    |                  ^
    = note: required for the cast from `Box<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ()>>, ()>>, ()>>` to `Box<(dyn Future<Error = Foo> + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/diagnostic-width/flag-human.stderr b/tests/ui/diagnostic-width/flag-human.stderr
index 393dcf2b828..eaa96841080 100644
--- a/tests/ui/diagnostic-width/flag-human.stderr
+++ b/tests/ui/diagnostic-width/flag-human.stderr
@@ -6,6 +6,6 @@ LL | ..._: () = 42;
    |       |
    |       expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/flag-json.stderr b/tests/ui/diagnostic-width/flag-json.stderr
index 16c17526809..f3bf4f97942 100644
--- a/tests/ui/diagnostic-width/flag-json.stderr
+++ b/tests/ui/diagnostic-width/flag-json.stderr
@@ -33,7 +33,7 @@ LL | ..._: () = 42;
    |       expected due to this
 
 "}
-{"$message_type":"diagnostic","message":"aborting due to previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to previous error
+{"$message_type":"diagnostic","message":"aborting due to 1 previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to 1 previous error
 
 "}
 {"$message_type":"diagnostic","message":"For more information about this error, try `rustc --explain E0308`.","code":null,"level":"failure-note","spans":[],"children":[],"rendered":"For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.stderr b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.stderr
index bf277362dba..8f200e15c64 100644
--- a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.stderr
+++ b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.stderr
@@ -13,6 +13,6 @@ help: create an owned `String` from a string reference
 LL |     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓༔༕༖༗༘༙༚༛༜༝༞༟༠༡༢༣༤༥༦༧༨༩༪༫༬༭༮༯༰༱༲༳༴༵༶༷༸༹༺༻༼༽༾༿ཀཁགགྷངཅཆཇ཈ཉཊཋཌཌྷཎཏཐདདྷནཔཕབབྷམཙཚཛཛྷཝཞཟའཡརལཤཥསཧཨཀྵཪཫཬ཭཮཯཰ཱཱཱིིུུྲྀཷླྀཹེཻོཽཾཿ྄ཱྀྀྂྃ྅྆྇ྈྉྊྋྌྍྎྏྐྑྒྒྷྔྕྖྗ྘ྙྚྛྜྜྷྞྟྠྡྡྷྣྤྥྦྦྷྨྩྪྫྫྷྭྮྯྰྱྲླྴྵྶྷྸྐྵྺྻྼ྽྾྿࿀࿁࿂࿃࿄࿅࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun.to_owned() + " really fun!";
    |                                                                                                                                                                                         +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-2.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming-2.stderr
index 5dbb9ce45ee..a7d5c0bfb94 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-2.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-2.stderr
@@ -6,6 +6,6 @@ LL | ...13; let _: usize = 14; let _: usize = 15; let _: () = 42; let _: usize =
    |                                                     |
    |                                                     expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr
index 1e5ff939832..da3d8d31892 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr
@@ -6,6 +6,6 @@ LL | ...♭♮♯♰♱♲♳♴♵♶♷♸♹♺♻♼♽♾♿⚀⚁⚂⚃⚄
    |                                            |
    |                                            expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming.stderr
index c4ff0e16890..872c5ae3b76 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming.stderr
@@ -6,6 +6,6 @@ LL | ... () = (); let _: () = (); let _: () = (); let _: () = 42; let _: () = ()
    |                                                     |
    |                                                     expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/tab-column-numbers.stderr b/tests/ui/diagnostic-width/tab-column-numbers.stderr
index ea4e1ff52a9..3093b66fe9d 100644
--- a/tests/ui/diagnostic-width/tab-column-numbers.stderr
+++ b/tests/ui/diagnostic-width/tab-column-numbers.stderr
@@ -9,6 +9,6 @@ LL |     s.method();
 LL |         fn method(&self) {}
    |         ---------------- private method defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/diagnostic-width/tabs-trimming.stderr b/tests/ui/diagnostic-width/tabs-trimming.stderr
index 6c8d9afc73b..2aa4fc18c3d 100644
--- a/tests/ui/diagnostic-width/tabs-trimming.stderr
+++ b/tests/ui/diagnostic-width/tabs-trimming.stderr
@@ -7,6 +7,6 @@ LL | ...   v @ 1 | 2 | 3 => panic!("You gave me too little money {}", v), // Lon
    |       |       pattern doesn't bind `v`
    |       variable not in all patterns
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/diagnostic-width/whitespace-trimming-2.stderr b/tests/ui/diagnostic-width/whitespace-trimming-2.stderr
index 97a64e603b7..561f9e613fe 100644
--- a/tests/ui/diagnostic-width/whitespace-trimming-2.stderr
+++ b/tests/ui/diagnostic-width/whitespace-trimming-2.stderr
@@ -6,6 +6,6 @@ LL | ...-> usize {
 LL | ...                                                                                                                                                                                 ()
    |                                                                                                                                                                                     ^^ expected `usize`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-width/whitespace-trimming.stderr b/tests/ui/diagnostic-width/whitespace-trimming.stderr
index e296d48893c..519ba8a1f5c 100644
--- a/tests/ui/diagnostic-width/whitespace-trimming.stderr
+++ b/tests/ui/diagnostic-width/whitespace-trimming.stderr
@@ -6,6 +6,6 @@ LL | ...                   let _: () = 42;
    |                              |
    |                              expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/feature-gate-diagnostic_on_unimplemented.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/feature-gate-diagnostic_on_unimplemented.stderr
index 21f02e3a73b..82e3b709f70 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/feature-gate-diagnostic_on_unimplemented.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/feature-gate-diagnostic_on_unimplemented.stderr
@@ -7,6 +7,6 @@ LL | #[diagnostic::on_unimplemented(message = "Foo")]
    = note: see issue #111996 <https://github.com/rust-lang/rust/issues/111996> for more information
    = help: add `#![feature(diagnostic_namespace)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr
index fc4aa8ef7d8..e00846da77b 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr
@@ -58,6 +58,6 @@ note: required by a bound in `takes_foo`
 LL | fn takes_foo(_: impl Foo) {}
    |                      ^^^ required by this bound in `takes_foo`
 
-error: aborting due to previous error; 4 warnings emitted
+error: aborting due to 1 previous error; 4 warnings emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/on_unimplemented_simple.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/on_unimplemented_simple.stderr
index 549c7caa720..de57f7044bf 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/on_unimplemented_simple.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/on_unimplemented_simple.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `takes_foo`
 LL | fn takes_foo(_: impl Foo) {}
    |                      ^^^ required by this bound in `takes_foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr
index f9395ae85bc..d30754dcf10 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr
@@ -62,6 +62,6 @@ note: required by a bound in `takes_foo`
 LL | fn takes_foo(_: impl Foo) {}
    |                      ^^^ required by this bound in `takes_foo`
 
-error: aborting due to previous error; 4 warnings emitted
+error: aborting due to 1 previous error; 4 warnings emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/diagnostic_namespace/requires_path.stderr b/tests/ui/diagnostic_namespace/requires_path.stderr
index ce867621daa..5d07d3a22d5 100644
--- a/tests/ui/diagnostic_namespace/requires_path.stderr
+++ b/tests/ui/diagnostic_namespace/requires_path.stderr
@@ -4,5 +4,5 @@ error: cannot find attribute `diagnostic` in this scope
 LL | #[diagnostic]
    |   ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/issue-114112.stderr b/tests/ui/did_you_mean/issue-114112.stderr
index d76b5f72e30..071c9614f13 100644
--- a/tests/ui/did_you_mean/issue-114112.stderr
+++ b/tests/ui/did_you_mean/issue-114112.stderr
@@ -9,5 +9,5 @@ help: use `::<...>` instead of `<...>` to specify lifetime, type, or const argum
 LL |         E::<i32>::A(v) => {
    |          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
index b69fcd5d32a..9cbce93c8e0 100644
--- a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
+++ b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-1.stderr
@@ -10,6 +10,6 @@ LL |     f1.foo(1usize);
              <Bar as Foo<i32>>
              <Bar as Foo<u8>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
index 2d50c09645d..6ac0bf21e4a 100644
--- a/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
+++ b/tests/ui/did_you_mean/issue-21659-show-relevant-trait-impls-2.stderr
@@ -14,6 +14,6 @@ LL |     f1.foo(1usize);
              <Bar as Foo<u16>>
              <Bar as Foo<u32>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/did_you_mean/issue-34337.stderr b/tests/ui/did_you_mean/issue-34337.stderr
index 1f18ea8923b..c727a565dbe 100644
--- a/tests/ui/did_you_mean/issue-34337.stderr
+++ b/tests/ui/did_you_mean/issue-34337.stderr
@@ -7,6 +7,6 @@ LL |     get(&mut key);
    |         cannot borrow as mutable
    |         help: try removing `&mut` here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/did_you_mean/issue-36798.stderr b/tests/ui/did_you_mean/issue-36798.stderr
index 9f82d4c44cf..70aa3c32bfb 100644
--- a/tests/ui/did_you_mean/issue-36798.stderr
+++ b/tests/ui/did_you_mean/issue-36798.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |     f.bar;
    |       ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/did_you_mean/issue-36798_unknown_field.stderr b/tests/ui/did_you_mean/issue-36798_unknown_field.stderr
index 4f216568979..733af860f58 100644
--- a/tests/ui/did_you_mean/issue-36798_unknown_field.stderr
+++ b/tests/ui/did_you_mean/issue-36798_unknown_field.stderr
@@ -6,6 +6,6 @@ LL |     f.zz;
    |
    = note: available field is: `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/did_you_mean/issue-37139.stderr b/tests/ui/did_you_mean/issue-37139.stderr
index dc1bdfaaed5..a07d83b31db 100644
--- a/tests/ui/did_you_mean/issue-37139.stderr
+++ b/tests/ui/did_you_mean/issue-37139.stderr
@@ -7,6 +7,6 @@ LL |             test(&mut x);
    |                  cannot borrow as mutable
    |                  help: try removing `&mut` here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/did_you_mean/issue-38147-1.stderr b/tests/ui/did_you_mean/issue-38147-1.stderr
index 790ad54a547..a0392113ab1 100644
--- a/tests/ui/did_you_mean/issue-38147-1.stderr
+++ b/tests/ui/did_you_mean/issue-38147-1.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     fn f(&mut self) {
    |          ~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/did_you_mean/issue-38147-3.stderr b/tests/ui/did_you_mean/issue-38147-3.stderr
index 5b32b5a782c..1d92f7742c1 100644
--- a/tests/ui/did_you_mean/issue-38147-3.stderr
+++ b/tests/ui/did_you_mean/issue-38147-3.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     s: &'a mut String
    |            +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/did_you_mean/issue-38147-4.stderr b/tests/ui/did_you_mean/issue-38147-4.stderr
index 38ab3c54d01..57309172194 100644
--- a/tests/ui/did_you_mean/issue-38147-4.stderr
+++ b/tests/ui/did_you_mean/issue-38147-4.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL | fn f(x: usize, f: &mut Foo) {
    |                    +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/did_you_mean/issue-40823.stderr b/tests/ui/did_you_mean/issue-40823.stderr
index 6f1ed355438..d9f69eb47d2 100644
--- a/tests/ui/did_you_mean/issue-40823.stderr
+++ b/tests/ui/did_you_mean/issue-40823.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     let mut buf = &mut [1, 2, 3, 4];
    |                    +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/did_you_mean/issue-46718-struct-pattern-dotdotdot.stderr b/tests/ui/did_you_mean/issue-46718-struct-pattern-dotdotdot.stderr
index 589b2c37849..92cbc03e0dd 100644
--- a/tests/ui/did_you_mean/issue-46718-struct-pattern-dotdotdot.stderr
+++ b/tests/ui/did_you_mean/issue-46718-struct-pattern-dotdotdot.stderr
@@ -9,5 +9,5 @@ help: to omit remaining fields, use `..`
 LL |             PersonalityInventory { expressivity: exp, .. } => exp
    |                                                       ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/println-typo.stderr b/tests/ui/did_you_mean/println-typo.stderr
index 43b7b1894e2..a1e0b1f1ba4 100644
--- a/tests/ui/did_you_mean/println-typo.stderr
+++ b/tests/ui/did_you_mean/println-typo.stderr
@@ -7,5 +7,5 @@ LL |     prinltn!();
    |
    = note: similarly named macro `println` defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/pub-macro-rules.stderr b/tests/ui/did_you_mean/pub-macro-rules.stderr
index 0bde5783b8c..ba9020460ce 100644
--- a/tests/ui/did_you_mean/pub-macro-rules.stderr
+++ b/tests/ui/did_you_mean/pub-macro-rules.stderr
@@ -4,5 +4,5 @@ error: can't qualify macro_rules invocation with `pub`
 LL |     pub macro_rules! foo {
    |     ^^^ help: try exporting the macro: `#[macro_export]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/recursion_limit.stderr b/tests/ui/did_you_mean/recursion_limit.stderr
index 70e49566ac0..bff57a63deb 100644
--- a/tests/ui/did_you_mean/recursion_limit.stderr
+++ b/tests/ui/did_you_mean/recursion_limit.stderr
@@ -56,6 +56,6 @@ note: required by a bound in `is_send`
 LL | fn is_send<T:Send>() { }
    |              ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/did_you_mean/recursion_limit_macro.stderr b/tests/ui/did_you_mean/recursion_limit_macro.stderr
index 71855cf1e20..dc4189ed9ab 100644
--- a/tests/ui/did_you_mean/recursion_limit_macro.stderr
+++ b/tests/ui/did_you_mean/recursion_limit_macro.stderr
@@ -10,5 +10,5 @@ LL |     recurse!(0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9);
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]` attribute to your crate (`recursion_limit_macro`)
    = note: this error originates in the macro `recurse` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/replace-impl-infer-ty-from-trait.stderr b/tests/ui/did_you_mean/replace-impl-infer-ty-from-trait.stderr
index 730836a40c2..2ca6436bb99 100644
--- a/tests/ui/did_you_mean/replace-impl-infer-ty-from-trait.stderr
+++ b/tests/ui/did_you_mean/replace-impl-infer-ty-from-trait.stderr
@@ -13,6 +13,6 @@ help: try replacing `_` with the types in the corresponding trait method signatu
 LL |     fn bar(i: i32, t: usize, s: &()) -> (usize, i32) {
    |               ~~~     ~~~~~     ~~~     ~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/directory_ownership/macro-expanded-mod.stderr b/tests/ui/directory_ownership/macro-expanded-mod.stderr
index 8976341b1ad..2cacd52b94e 100644
--- a/tests/ui/directory_ownership/macro-expanded-mod.stderr
+++ b/tests/ui/directory_ownership/macro-expanded-mod.stderr
@@ -9,5 +9,5 @@ LL |     mod_decl!(foo);
    |
    = note: this error originates in the macro `mod_decl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/directory_ownership/non-inline-mod-restriction.stderr b/tests/ui/directory_ownership/non-inline-mod-restriction.stderr
index 64189bee43f..882c8652520 100644
--- a/tests/ui/directory_ownership/non-inline-mod-restriction.stderr
+++ b/tests/ui/directory_ownership/non-inline-mod-restriction.stderr
@@ -4,5 +4,5 @@ error: cannot declare a non-inline module inside a block unless it has a path at
 LL |     mod foo;
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr
index 596ad4bf784..45c7a8bb475 100644
--- a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr
+++ b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-let.stderr
@@ -12,6 +12,6 @@ help: consider borrowing the pattern binding
 LL |     let X { x: ref y } = x;
    |                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0509`.
diff --git a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr
index e32a4dd4411..837904cbae0 100644
--- a/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr
+++ b/tests/ui/disallowed-deconstructing/disallowed-deconstructing-destructing-struct-match.stderr
@@ -15,6 +15,6 @@ help: consider borrowing the pattern binding
 LL |         X { x: ref y } => println!("contents: {}", y)
    |                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0509`.
diff --git a/tests/ui/diverging-fn-tail-35849.stderr b/tests/ui/diverging-fn-tail-35849.stderr
index f5b5a4cccad..614f9b9cb5d 100644
--- a/tests/ui/diverging-fn-tail-35849.stderr
+++ b/tests/ui/diverging-fn-tail-35849.stderr
@@ -10,6 +10,6 @@ LL |         ::std::mem::transmute::<f64, [u8; 8]>(panic!())
    = note: expected type `!`
              found array `[u8; 8]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/does-nothing.stderr b/tests/ui/does-nothing.stderr
index dca79231517..d5ea3626e81 100644
--- a/tests/ui/does-nothing.stderr
+++ b/tests/ui/does-nothing.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `this_does_nothing_what_the` in this scope
 LL | fn main() { println!("doing"); this_does_nothing_what_the; println!("boing"); }
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/dont-suggest-private-trait-method.stderr b/tests/ui/dont-suggest-private-trait-method.stderr
index 1492670dc63..f251ad59a58 100644
--- a/tests/ui/dont-suggest-private-trait-method.stderr
+++ b/tests/ui/dont-suggest-private-trait-method.stderr
@@ -7,6 +7,6 @@ LL | struct T;
 LL |     T::new();
    |        ^^^ function or associated item not found in `T`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/double-type-import.stderr b/tests/ui/double-type-import.stderr
index a2f30d82ec3..8a8fe05ec19 100644
--- a/tests/ui/double-type-import.stderr
+++ b/tests/ui/double-type-import.stderr
@@ -8,6 +8,6 @@ LL |     use self::bar::X;
    |
    = note: `X` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/drop/drop-foreign-fundamental.stderr b/tests/ui/drop/drop-foreign-fundamental.stderr
index fbd1ba08591..a4b322106df 100644
--- a/tests/ui/drop/drop-foreign-fundamental.stderr
+++ b/tests/ui/drop/drop-foreign-fundamental.stderr
@@ -4,6 +4,6 @@ error[E0120]: the `Drop` trait may only be implemented for local structs, enums,
 LL | impl Drop for Pin<Whatever<A>> {
    |               ^^^^^^^^^^^^^^^^ must be a struct, enum, or union in the current crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0120`.
diff --git a/tests/ui/dropck/drop-with-active-borrows-1.stderr b/tests/ui/dropck/drop-with-active-borrows-1.stderr
index 0409ffa02b1..229514c6fee 100644
--- a/tests/ui/dropck/drop-with-active-borrows-1.stderr
+++ b/tests/ui/dropck/drop-with-active-borrows-1.stderr
@@ -10,6 +10,6 @@ LL |     drop(a);
 LL |     for s in &b {
    |              -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/dropck/drop-with-active-borrows-2.stderr b/tests/ui/dropck/drop-with-active-borrows-2.stderr
index ffec9306b77..9d5c500f8cc 100644
--- a/tests/ui/dropck/drop-with-active-borrows-2.stderr
+++ b/tests/ui/dropck/drop-with-active-borrows-2.stderr
@@ -7,6 +7,6 @@ LL |     raw_lines.iter().map(|l| l.trim()).collect()
    |     returns a value referencing data owned by the current function
    |     `raw_lines` is borrowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/dropck/dropck-union.stderr b/tests/ui/dropck/dropck-union.stderr
index 7d48e9fdcee..7828aaf23fb 100644
--- a/tests/ui/dropck/dropck-union.stderr
+++ b/tests/ui/dropck/dropck-union.stderr
@@ -11,6 +11,6 @@ LL | }
    | `v` dropped here while still borrowed
    | borrow might be used here, when `v` is dropped and runs the `Drop` code for type `Wrap`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/dropck/dropck_no_diverge_on_nonregular_1.stderr b/tests/ui/dropck/dropck_no_diverge_on_nonregular_1.stderr
index 3e39d15f9b0..8f4d301b5ca 100644
--- a/tests/ui/dropck/dropck_no_diverge_on_nonregular_1.stderr
+++ b/tests/ui/dropck/dropck_no_diverge_on_nonregular_1.stderr
@@ -6,6 +6,6 @@ LL |     let ft =
    |
    = note: overflowed on FingerTree<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<i32>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0320`.
diff --git a/tests/ui/dropck/dropck_no_diverge_on_nonregular_2.stderr b/tests/ui/dropck/dropck_no_diverge_on_nonregular_2.stderr
index dbb74354471..4ef7aa61db7 100644
--- a/tests/ui/dropck/dropck_no_diverge_on_nonregular_2.stderr
+++ b/tests/ui/dropck/dropck_no_diverge_on_nonregular_2.stderr
@@ -6,6 +6,6 @@ LL |     let ft =
    |
    = note: overflowed on FingerTree<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<Node<i32>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0320`.
diff --git a/tests/ui/dropck/explicit-implied-outlives.bad1.stderr b/tests/ui/dropck/explicit-implied-outlives.bad1.stderr
index bf6d70e7d37..82bc7bc0822 100644
--- a/tests/ui/dropck/explicit-implied-outlives.bad1.stderr
+++ b/tests/ui/dropck/explicit-implied-outlives.bad1.stderr
@@ -10,6 +10,6 @@ note: the implementor must specify the same requirement
 LL | struct DropMe<'a, T>(&'a T);
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/dropck/explicit-implied-outlives.bad2.stderr b/tests/ui/dropck/explicit-implied-outlives.bad2.stderr
index 27a15170bdd..9d2436f058c 100644
--- a/tests/ui/dropck/explicit-implied-outlives.bad2.stderr
+++ b/tests/ui/dropck/explicit-implied-outlives.bad2.stderr
@@ -10,6 +10,6 @@ note: the implementor must specify the same requirement
 LL | struct DropMe<'a, T>(&'a T);
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/dropck/issue-38868.stderr b/tests/ui/dropck/issue-38868.stderr
index ec81c2ea646..61fef42fdd2 100644
--- a/tests/ui/dropck/issue-38868.stderr
+++ b/tests/ui/dropck/issue-38868.stderr
@@ -11,6 +11,6 @@ note: use the same sequence of generic lifetime, type and const parameters as th
 LL | pub struct List<T> {
    | ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0366`.
diff --git a/tests/ui/dropck/negative.stderr b/tests/ui/dropck/negative.stderr
index d613e30b5ea..886b05e347c 100644
--- a/tests/ui/dropck/negative.stderr
+++ b/tests/ui/dropck/negative.stderr
@@ -4,5 +4,5 @@ error: negative `Drop` impls are not supported
 LL | impl !Drop for NonDrop {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/dropck/relate_lt_in_type_outlives_bound.stderr b/tests/ui/dropck/relate_lt_in_type_outlives_bound.stderr
index 3d9685db683..9c13b6dc258 100644
--- a/tests/ui/dropck/relate_lt_in_type_outlives_bound.stderr
+++ b/tests/ui/dropck/relate_lt_in_type_outlives_bound.stderr
@@ -10,6 +10,6 @@ note: the implementor must specify the same requirement
 LL | struct Wrapper<'a, T>(&'a T)
    | ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/dropck/reservation.stderr b/tests/ui/dropck/reservation.stderr
index 19325d6ed44..a6ebf158a07 100644
--- a/tests/ui/dropck/reservation.stderr
+++ b/tests/ui/dropck/reservation.stderr
@@ -4,5 +4,5 @@ error: reservation `Drop` impls are not supported
 LL | impl Drop for ReservedDrop {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/dropck/transitive-outlives.bad.stderr b/tests/ui/dropck/transitive-outlives.bad.stderr
index da5088b27b4..9ecc4841dce 100644
--- a/tests/ui/dropck/transitive-outlives.bad.stderr
+++ b/tests/ui/dropck/transitive-outlives.bad.stderr
@@ -10,6 +10,6 @@ note: the implementor must specify the same requirement
 LL | struct DropMe<'a, 'b: 'a, 'c: 'b>(PhantomData<&'a ()>, PhantomData<&'b ()>, PhantomData<&'c ()>);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/dst/dst-bad-assign-2.stderr b/tests/ui/dst/dst-bad-assign-2.stderr
index 6c9e2971c6d..bca22036fb8 100644
--- a/tests/ui/dst/dst-bad-assign-2.stderr
+++ b/tests/ui/dst/dst-bad-assign-2.stderr
@@ -7,6 +7,6 @@ LL |     f5.ptr = *z;
    = help: the trait `Sized` is not implemented for `dyn ToBar`
    = note: the left-hand-side of an assignment must have a statically known size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dst/dst-bad-deep-2.stderr b/tests/ui/dst/dst-bad-deep-2.stderr
index b2285081410..c7e9854340f 100644
--- a/tests/ui/dst/dst-bad-deep-2.stderr
+++ b/tests/ui/dst/dst-bad-deep-2.stderr
@@ -9,6 +9,6 @@ LL |     let h: &(([isize],),) = &(*g,);
    = note: required because it appears within the type `(([isize],),)`
    = note: tuples must have a statically known size to be initialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dst/dst-bad-deep.stderr b/tests/ui/dst/dst-bad-deep.stderr
index 98db7959115..1b0f9738ab0 100644
--- a/tests/ui/dst/dst-bad-deep.stderr
+++ b/tests/ui/dst/dst-bad-deep.stderr
@@ -12,6 +12,6 @@ LL | struct Fat<T: ?Sized> {
    |        ^^^
    = note: structs must have a statically known size to be initialized
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dst/issue-113447.stderr b/tests/ui/dst/issue-113447.stderr
index 240553a675b..266eb228046 100644
--- a/tests/ui/dst/issue-113447.stderr
+++ b/tests/ui/dst/issue-113447.stderr
@@ -20,6 +20,6 @@ help: convert the array to a `&[u8]` slice instead
 LL |     let _ = &[0u8] == &[0xAA][..];
    |                       +      ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/duplicate/dupe-symbols-1.stderr b/tests/ui/duplicate/dupe-symbols-1.stderr
index 933ed5e89e5..03ebc9d6e7a 100644
--- a/tests/ui/duplicate/dupe-symbols-1.stderr
+++ b/tests/ui/duplicate/dupe-symbols-1.stderr
@@ -4,5 +4,5 @@ error: symbol `fail` is already defined
 LL | pub fn b() {
    | ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-2.stderr b/tests/ui/duplicate/dupe-symbols-2.stderr
index b132eae4b88..091c3051e7c 100644
--- a/tests/ui/duplicate/dupe-symbols-2.stderr
+++ b/tests/ui/duplicate/dupe-symbols-2.stderr
@@ -4,5 +4,5 @@ error: symbol `fail` is already defined
 LL |     pub extern "C" fn fail() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-3.stderr b/tests/ui/duplicate/dupe-symbols-3.stderr
index 6300b4908d1..9417f8817a8 100644
--- a/tests/ui/duplicate/dupe-symbols-3.stderr
+++ b/tests/ui/duplicate/dupe-symbols-3.stderr
@@ -4,5 +4,5 @@ error: symbol `fail` is already defined
 LL | pub fn fail() {
    | ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-4.stderr b/tests/ui/duplicate/dupe-symbols-4.stderr
index 1407a4883e1..4c5f1e7867f 100644
--- a/tests/ui/duplicate/dupe-symbols-4.stderr
+++ b/tests/ui/duplicate/dupe-symbols-4.stderr
@@ -4,5 +4,5 @@ error: symbol `fail` is already defined
 LL |     fn fail(self) {}
    |     ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-5.stderr b/tests/ui/duplicate/dupe-symbols-5.stderr
index 558f868a0c6..74c296e33a6 100644
--- a/tests/ui/duplicate/dupe-symbols-5.stderr
+++ b/tests/ui/duplicate/dupe-symbols-5.stderr
@@ -4,5 +4,5 @@ error: symbol `fail` is already defined
 LL | pub fn b() {
    | ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-6.stderr b/tests/ui/duplicate/dupe-symbols-6.stderr
index 6692a63dce8..2be68132787 100644
--- a/tests/ui/duplicate/dupe-symbols-6.stderr
+++ b/tests/ui/duplicate/dupe-symbols-6.stderr
@@ -4,5 +4,5 @@ error: symbol `fail` is already defined
 LL | static HELLO_TWICE: u16 = 0;
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-7.stderr b/tests/ui/duplicate/dupe-symbols-7.stderr
index cd5147c0e15..23f74ef7509 100644
--- a/tests/ui/duplicate/dupe-symbols-7.stderr
+++ b/tests/ui/duplicate/dupe-symbols-7.stderr
@@ -6,5 +6,5 @@ LL | fn main(){}
    |
    = help: did you use `#[no_mangle]` on `fn main`? Use `#[start]` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/dupe-symbols-8.stderr b/tests/ui/duplicate/dupe-symbols-8.stderr
index 8d6a79e12d9..67eb0bc71a9 100644
--- a/tests/ui/duplicate/dupe-symbols-8.stderr
+++ b/tests/ui/duplicate/dupe-symbols-8.stderr
@@ -6,5 +6,5 @@ LL | fn main() {
    |
    = help: did you use `#[no_mangle]` on `fn main`? Use `#[start]` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/duplicate/duplicate-check-macro-exports.stderr b/tests/ui/duplicate/duplicate-check-macro-exports.stderr
index ba723b38bfa..eff19c09062 100644
--- a/tests/ui/duplicate/duplicate-check-macro-exports.stderr
+++ b/tests/ui/duplicate/duplicate-check-macro-exports.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | pub use std::panic as other_panic;
    |         ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/duplicate/duplicate-parameter.stderr b/tests/ui/duplicate/duplicate-parameter.stderr
index f3ef0bcf3a0..413d8b6f8a4 100644
--- a/tests/ui/duplicate/duplicate-parameter.stderr
+++ b/tests/ui/duplicate/duplicate-parameter.stderr
@@ -4,6 +4,6 @@ error[E0415]: identifier `a` is bound more than once in this parameter list
 LL | fn f(a: isize, a: isize) {}
    |                ^ used as parameter more than once
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0415`.
diff --git a/tests/ui/duplicate_entry_error.stderr b/tests/ui/duplicate_entry_error.stderr
index 6d078dfbd20..592640a884c 100644
--- a/tests/ui/duplicate_entry_error.stderr
+++ b/tests/ui/duplicate_entry_error.stderr
@@ -8,6 +8,6 @@ LL | fn panic_impl(info: &PanicInfo) -> ! {
    = note: first definition in `std` loaded from SYSROOT/libstd-*.rlib
    = note: second definition in the local crate (`duplicate_entry_error`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0152`.
diff --git a/tests/ui/dyn-keyword/dyn-angle-brackets.stderr b/tests/ui/dyn-keyword/dyn-angle-brackets.stderr
index 0bb764d712e..0b194cb8364 100644
--- a/tests/ui/dyn-keyword/dyn-angle-brackets.stderr
+++ b/tests/ui/dyn-keyword/dyn-angle-brackets.stderr
@@ -16,5 +16,5 @@ help: use `dyn`
 LL |         <dyn fmt::Debug>::fmt(self, f)
    |          +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/dyn-star/align.normal.stderr b/tests/ui/dyn-star/align.normal.stderr
index 42fa4fd6f00..d3ee0d3e550 100644
--- a/tests/ui/dyn-star/align.normal.stderr
+++ b/tests/ui/dyn-star/align.normal.stderr
@@ -15,6 +15,6 @@ LL |     let x = AlignedUsize(12) as dyn* Debug;
    |
    = help: the trait `PointerLike` is not implemented for `AlignedUsize`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/align.over_aligned.stderr b/tests/ui/dyn-star/align.over_aligned.stderr
index 42fa4fd6f00..d3ee0d3e550 100644
--- a/tests/ui/dyn-star/align.over_aligned.stderr
+++ b/tests/ui/dyn-star/align.over_aligned.stderr
@@ -15,6 +15,6 @@ LL |     let x = AlignedUsize(12) as dyn* Debug;
    |
    = help: the trait `PointerLike` is not implemented for `AlignedUsize`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr
index ba42f619a54..f291b1e2ca3 100644
--- a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr
+++ b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.current.stderr
@@ -10,6 +10,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn polymorphic<T: Debug + ?Sized>(t: &T) where &T: PointerLike {
    |                                          +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr
index ba42f619a54..f291b1e2ca3 100644
--- a/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr
+++ b/tests/ui/dyn-star/check-size-at-cast-polymorphic-bad.next.stderr
@@ -10,6 +10,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn polymorphic<T: Debug + ?Sized>(t: &T) where &T: PointerLike {
    |                                          +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/check-size-at-cast.stderr b/tests/ui/dyn-star/check-size-at-cast.stderr
index e60b5c56ff0..b402403ee6f 100644
--- a/tests/ui/dyn-star/check-size-at-cast.stderr
+++ b/tests/ui/dyn-star/check-size-at-cast.stderr
@@ -6,6 +6,6 @@ LL |     let i = [1, 2, 3, 4] as dyn* Debug;
    |
    = help: the trait `PointerLike` is not implemented for `[i32; 4]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/dyn-to-rigid.stderr b/tests/ui/dyn-star/dyn-to-rigid.stderr
index 588e6d97e5c..b198c5245de 100644
--- a/tests/ui/dyn-star/dyn-to-rigid.stderr
+++ b/tests/ui/dyn-star/dyn-to-rigid.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `(dyn* Tr + 'static)` as `usize` is invalid
 LL |     x as usize
    |     ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/dyn-star/error.stderr b/tests/ui/dyn-star/error.stderr
index e039bb6f1c8..a9f4a054519 100644
--- a/tests/ui/dyn-star/error.stderr
+++ b/tests/ui/dyn-star/error.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Foo {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/feature-gate-dyn_star.stderr b/tests/ui/dyn-star/feature-gate-dyn_star.stderr
index 342e71c3a3a..d8fe25b84bd 100644
--- a/tests/ui/dyn-star/feature-gate-dyn_star.stderr
+++ b/tests/ui/dyn-star/feature-gate-dyn_star.stderr
@@ -7,6 +7,6 @@ LL | pub fn dyn_star_parameter(_: &dyn* Send) {
    = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
    = help: add `#![feature(dyn_star)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/dyn-star/gated-span.stderr b/tests/ui/dyn-star/gated-span.stderr
index 626b6cd1b7f..da5afa2d578 100644
--- a/tests/ui/dyn-star/gated-span.stderr
+++ b/tests/ui/dyn-star/gated-span.stderr
@@ -7,6 +7,6 @@ LL | t!(dyn* Send);
    = note: see issue #102425 <https://github.com/rust-lang/rust/issues/102425> for more information
    = help: add `#![feature(dyn_star)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/dyn-star/no-explicit-dyn-star.stderr b/tests/ui/dyn-star/no-explicit-dyn-star.stderr
index 49706fae19e..641404aa09e 100644
--- a/tests/ui/dyn-star/no-explicit-dyn-star.stderr
+++ b/tests/ui/dyn-star/no-explicit-dyn-star.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `usize` as `dyn* std::fmt::Display` is invalid
 LL |     dyn_star_foreign::require_dyn_star_display(1usize as _);
    |                                                ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/dyn-star/no-implicit-dyn-star.stderr b/tests/ui/dyn-star/no-implicit-dyn-star.stderr
index 66e1b9a092c..06c7bcc5748 100644
--- a/tests/ui/dyn-star/no-implicit-dyn-star.stderr
+++ b/tests/ui/dyn-star/no-implicit-dyn-star.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | pub fn require_dyn_star_display(_: dyn* Display) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr b/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr
index 50aa79f5c0f..7e2cf661369 100644
--- a/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr
+++ b/tests/ui/dyn-star/no-unsize-coerce-dyn-trait.stderr
@@ -18,6 +18,6 @@ LL |     let y: Box<dyn* B> = x;
    = note: expected struct `Box<dyn* B>`
               found struct `Box<dyn* A>`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/dyn-star/param-env-region-infer.current.stderr b/tests/ui/dyn-star/param-env-region-infer.current.stderr
index b982be45196..b50117c1efb 100644
--- a/tests/ui/dyn-star/param-env-region-infer.current.stderr
+++ b/tests/ui/dyn-star/param-env-region-infer.current.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     t as _
    |          ^ cannot infer type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr b/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr
index f6444a60a46..b3274580afe 100644
--- a/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr
+++ b/tests/ui/dyn-star/unsize-into-ref-dyn-star.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `i32` as `&dyn* Debug`
 LL |     let i = 42 as &dyn* Debug;
    |             ^^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/dyn-star/upcast.stderr b/tests/ui/dyn-star/upcast.stderr
index a7a40c80186..bdf77da713a 100644
--- a/tests/ui/dyn-star/upcast.stderr
+++ b/tests/ui/dyn-star/upcast.stderr
@@ -15,6 +15,6 @@ LL |     let w: dyn* Bar = w;
    |
    = help: the trait `PointerLike` is not implemented for `dyn* Foo`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/editions/dyn-trait-sugg-2021.stderr b/tests/ui/editions/dyn-trait-sugg-2021.stderr
index 8c68dec1df7..8a65fea11c9 100644
--- a/tests/ui/editions/dyn-trait-sugg-2021.stderr
+++ b/tests/ui/editions/dyn-trait-sugg-2021.stderr
@@ -9,6 +9,6 @@ help: add `dyn` keyword before this trait
 LL |     <dyn Foo>::hi(123);
    |     ++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0782`.
diff --git a/tests/ui/editions/edition-imports-2015.stderr b/tests/ui/editions/edition-imports-2015.stderr
index 3f38e6f8e80..606843361f8 100644
--- a/tests/ui/editions/edition-imports-2015.stderr
+++ b/tests/ui/editions/edition-imports-2015.stderr
@@ -6,5 +6,5 @@ LL |     gen_glob!();
    |
    = note: this error originates in the macro `gen_glob` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/editions/edition-imports-2018.stderr b/tests/ui/editions/edition-imports-2018.stderr
index e7f760e49bc..4776478b976 100644
--- a/tests/ui/editions/edition-imports-2018.stderr
+++ b/tests/ui/editions/edition-imports-2018.stderr
@@ -6,5 +6,5 @@ LL |     gen_glob!();
    |
    = note: this error originates in the macro `gen_glob` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/editions/edition-imports-virtual-2015-gated.stderr b/tests/ui/editions/edition-imports-virtual-2015-gated.stderr
index e4bdd28213e..83c648e54aa 100644
--- a/tests/ui/editions/edition-imports-virtual-2015-gated.stderr
+++ b/tests/ui/editions/edition-imports-virtual-2015-gated.stderr
@@ -6,6 +6,6 @@ LL |     gen_gated!();
    |
    = note: this error originates in the macro `gen_gated` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/editions/edition-keywords-2015-2018-expansion.stderr b/tests/ui/editions/edition-keywords-2015-2018-expansion.stderr
index 570bbac2b21..c66ccf1ba78 100644
--- a/tests/ui/editions/edition-keywords-2015-2018-expansion.stderr
+++ b/tests/ui/editions/edition-keywords-2015-2018-expansion.stderr
@@ -11,5 +11,5 @@ help: escape `async` to use it as an identifier
 LL |     () => (pub fn r#async() {})
    |                   ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/editions/edition-keywords-2018-2018-expansion.stderr b/tests/ui/editions/edition-keywords-2018-2018-expansion.stderr
index 69f275746bd..6bfc06ad799 100644
--- a/tests/ui/editions/edition-keywords-2018-2018-expansion.stderr
+++ b/tests/ui/editions/edition-keywords-2018-2018-expansion.stderr
@@ -11,5 +11,5 @@ help: escape `async` to use it as an identifier
 LL |     () => (pub fn r#async() {})
    |                   ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/editions/edition-raw-pointer-method-2015.stderr b/tests/ui/editions/edition-raw-pointer-method-2015.stderr
index 612dd17e71e..3d8b3f633ce 100644
--- a/tests/ui/editions/edition-raw-pointer-method-2015.stderr
+++ b/tests/ui/editions/edition-raw-pointer-method-2015.stderr
@@ -13,5 +13,5 @@ LL | #[deny(warnings)]
    |        ^^^^^^^^
    = note: `#[deny(tyvar_behind_raw_pointer)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/editions/edition-raw-pointer-method-2018.stderr b/tests/ui/editions/edition-raw-pointer-method-2018.stderr
index b9afa0133ca..663843ad7bc 100644
--- a/tests/ui/editions/edition-raw-pointer-method-2018.stderr
+++ b/tests/ui/editions/edition-raw-pointer-method-2018.stderr
@@ -4,6 +4,6 @@ error[E0699]: cannot call a method on a raw pointer with an unknown pointee type
 LL |     let _ = y.is_null();
    |               ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0699`.
diff --git a/tests/ui/elide-errors-on-mismatched-tuple.stderr b/tests/ui/elide-errors-on-mismatched-tuple.stderr
index e0537ff6faa..f852a223b42 100644
--- a/tests/ui/elide-errors-on-mismatched-tuple.stderr
+++ b/tests/ui/elide-errors-on-mismatched-tuple.stderr
@@ -9,6 +9,6 @@ LL |     let (a, b, c) = (A::new(), A::new()); // This tuple is 2 elements, shou
    = note: expected tuple `(A, A)`
               found tuple `(_, _, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/elided-test.stderr b/tests/ui/elided-test.stderr
index c74c307c492..e323b8ba7ea 100644
--- a/tests/ui/elided-test.stderr
+++ b/tests/ui/elided-test.stderr
@@ -4,6 +4,6 @@ error[E0601]: `main` function not found in crate `elided_test`
 LL | }
    |  ^ consider adding a `main` function to `$DIR/elided-test.rs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/empty/empty-comment.stderr b/tests/ui/empty/empty-comment.stderr
index 7cc8d8fe922..07a1d9b45c7 100644
--- a/tests/ui/empty/empty-comment.stderr
+++ b/tests/ui/empty/empty-comment.stderr
@@ -13,5 +13,5 @@ note: while trying to match meta-variable `$fmt:expr`
 LL |     ($fmt:expr) => (print!(concat!($fmt, "\n")));
    |      ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/empty/empty-linkname.stderr b/tests/ui/empty/empty-linkname.stderr
index adcf3670d1d..9fbcbc3ca9d 100644
--- a/tests/ui/empty/empty-linkname.stderr
+++ b/tests/ui/empty/empty-linkname.stderr
@@ -4,6 +4,6 @@ error[E0454]: link name must not be empty
 LL | #[link(name = "")]
    |               ^^ empty link name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0454`.
diff --git a/tests/ui/empty/empty-macro-use.stderr b/tests/ui/empty/empty-macro-use.stderr
index 5d552e4c408..cdf3ff83cc3 100644
--- a/tests/ui/empty/empty-macro-use.stderr
+++ b/tests/ui/empty/empty-macro-use.stderr
@@ -9,5 +9,5 @@ help: consider importing this macro
 LL + use two_macros::macro_two;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/empty/empty-never-array.stderr b/tests/ui/empty/empty-never-array.stderr
index a488e484b2b..0104a435538 100644
--- a/tests/ui/empty/empty-never-array.stderr
+++ b/tests/ui/empty/empty-never-array.stderr
@@ -19,6 +19,6 @@ help: you might want to use `let else` to handle the variant that isn't matched
 LL |     let Helper::U(u) = Helper::T(t, []) else { todo!() };
    |                                         ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/entry-point/imported_main_conflict.stderr b/tests/ui/entry-point/imported_main_conflict.stderr
index 8fadd0e19b3..783e9345acf 100644
--- a/tests/ui/entry-point/imported_main_conflict.stderr
+++ b/tests/ui/entry-point/imported_main_conflict.stderr
@@ -14,6 +14,6 @@ LL | use m2::*;
    |     ^^^^^
    = help: consider adding an explicit import of `main` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/entry-point/imported_main_const_fn_item_type_forbidden.stderr b/tests/ui/entry-point/imported_main_const_fn_item_type_forbidden.stderr
index fabb6ffb02f..1e7d82a73bc 100644
--- a/tests/ui/entry-point/imported_main_const_fn_item_type_forbidden.stderr
+++ b/tests/ui/entry-point/imported_main_const_fn_item_type_forbidden.stderr
@@ -6,6 +6,6 @@ LL | use foo::BAR as main;
    |     |
    |     non-function item at `crate::main` is found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/entry-point/imported_main_const_forbidden.stderr b/tests/ui/entry-point/imported_main_const_forbidden.stderr
index 9d8b40dc3c9..6f34015a2cd 100644
--- a/tests/ui/entry-point/imported_main_const_forbidden.stderr
+++ b/tests/ui/entry-point/imported_main_const_forbidden.stderr
@@ -6,6 +6,6 @@ LL | use foo::BAR as main;
    |     |
    |     non-function item at `crate::main` is found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/entry-point/imported_main_from_extern_crate_wrong_type.stderr b/tests/ui/entry-point/imported_main_from_extern_crate_wrong_type.stderr
index 3c68933101c..ce4a94670a7 100644
--- a/tests/ui/entry-point/imported_main_from_extern_crate_wrong_type.stderr
+++ b/tests/ui/entry-point/imported_main_from_extern_crate_wrong_type.stderr
@@ -7,6 +7,6 @@ LL | pub fn boilerplate(x: u8) {}
    = note: expected signature `fn()`
               found signature `fn(u8)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0580`.
diff --git a/tests/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr b/tests/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr
index 8cee7469629..3b718c6465b 100644
--- a/tests/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr
+++ b/tests/ui/enum-discriminant/arbitrary_enum_discriminant-no-repr.stderr
@@ -4,6 +4,6 @@ error[E0732]: `#[repr(inttype)]` must be specified
 LL | enum Enum {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0732`.
diff --git a/tests/ui/enum-discriminant/forbidden-discriminant-kind-impl.stderr b/tests/ui/enum-discriminant/forbidden-discriminant-kind-impl.stderr
index 38cfd13b9b8..054bd25a400 100644
--- a/tests/ui/enum-discriminant/forbidden-discriminant-kind-impl.stderr
+++ b/tests/ui/enum-discriminant/forbidden-discriminant-kind-impl.stderr
@@ -4,6 +4,6 @@ error[E0322]: explicit impls for the `DiscriminantKind` trait are not permitted
 LL | impl DiscriminantKind for NewType {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl of `DiscriminantKind` not allowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0322`.
diff --git a/tests/ui/enum-discriminant/issue-41394.stderr b/tests/ui/enum-discriminant/issue-41394.stderr
index fa95ca9c18a..e81562df04f 100644
--- a/tests/ui/enum-discriminant/issue-41394.stderr
+++ b/tests/ui/enum-discriminant/issue-41394.stderr
@@ -6,6 +6,6 @@ LL |     A = "" + 1
    |         |
    |         &str
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/enum-discriminant/issue-70453-generics-in-discr-ice-2.stderr b/tests/ui/enum-discriminant/issue-70453-generics-in-discr-ice-2.stderr
index 2cb159ee291..01d83e6ded3 100644
--- a/tests/ui/enum-discriminant/issue-70453-generics-in-discr-ice-2.stderr
+++ b/tests/ui/enum-discriminant/issue-70453-generics-in-discr-ice-2.stderr
@@ -6,5 +6,5 @@ LL |     Some(T) = std::mem::size_of::<T>(),
    |
    = note: type parameters may not be used in enum discriminant values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/enum-discriminant/issue-70453-polymorphic-ctfe.stderr b/tests/ui/enum-discriminant/issue-70453-polymorphic-ctfe.stderr
index 15cd6d30364..39f0d086ccb 100644
--- a/tests/ui/enum-discriminant/issue-70453-polymorphic-ctfe.stderr
+++ b/tests/ui/enum-discriminant/issue-70453-polymorphic-ctfe.stderr
@@ -6,5 +6,5 @@ LL |     Some(T) = core::mem::size_of::<*mut T>(),
    |
    = note: type parameters may not be used in enum discriminant values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/enum-discriminant/issue-72554.stderr b/tests/ui/enum-discriminant/issue-72554.stderr
index d12be539f7c..381f24d351e 100644
--- a/tests/ui/enum-discriminant/issue-72554.stderr
+++ b/tests/ui/enum-discriminant/issue-72554.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     A(Box<ElemDerived>)
    |       ++++           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/enum/enum-and-module-in-same-scope.stderr b/tests/ui/enum/enum-and-module-in-same-scope.stderr
index 538898c2f2a..0293acd6201 100644
--- a/tests/ui/enum/enum-and-module-in-same-scope.stderr
+++ b/tests/ui/enum/enum-and-module-in-same-scope.stderr
@@ -9,6 +9,6 @@ LL | mod Foo {
    |
    = note: `Foo` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/enum/enum-discrim-autosizing.stderr b/tests/ui/enum/enum-discrim-autosizing.stderr
index be3d7c64e28..03c722a68b4 100644
--- a/tests/ui/enum/enum-discrim-autosizing.stderr
+++ b/tests/ui/enum/enum-discrim-autosizing.stderr
@@ -10,6 +10,6 @@ LL |
 LL |     Bu64 = 0x8000_0000_0000_0000
    |            --------------------- `0` (overflowed from `9223372036854775808`) assigned here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0081`.
diff --git a/tests/ui/enum/enum-in-scope.stderr b/tests/ui/enum/enum-in-scope.stderr
index 49a01abcbd6..9c0dd8f3dd8 100644
--- a/tests/ui/enum/enum-in-scope.stderr
+++ b/tests/ui/enum/enum-in-scope.stderr
@@ -7,6 +7,6 @@ LL | struct hello(isize);
 LL |     let hello = 0;
    |         ^^^^^ cannot be named the same as a tuple struct
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0530`.
diff --git a/tests/ui/enum/enum-variant-type-2.stderr b/tests/ui/enum/enum-variant-type-2.stderr
index 7e8453c61f6..216dbda5dd7 100644
--- a/tests/ui/enum/enum-variant-type-2.stderr
+++ b/tests/ui/enum/enum-variant-type-2.stderr
@@ -7,6 +7,6 @@ LL | fn foo(x: Foo::Bar) {}
    |           not a type
    |           help: try using the variant's enum: `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0573`.
diff --git a/tests/ui/enum/suggest-default-attribute.stderr b/tests/ui/enum/suggest-default-attribute.stderr
index b56d599a786..fa72db6aaef 100644
--- a/tests/ui/enum/suggest-default-attribute.stderr
+++ b/tests/ui/enum/suggest-default-attribute.stderr
@@ -10,5 +10,5 @@ LL + #[derive(Default)]
 LL | pub enum Test {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0001.stderr b/tests/ui/error-codes/E0001.stderr
index 577c49032d7..49bb73e7ba8 100644
--- a/tests/ui/error-codes/E0001.stderr
+++ b/tests/ui/error-codes/E0001.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0004-2.stderr b/tests/ui/error-codes/E0004-2.stderr
index e829bac196f..cc4e18f76d0 100644
--- a/tests/ui/error-codes/E0004-2.stderr
+++ b/tests/ui/error-codes/E0004-2.stderr
@@ -20,6 +20,6 @@ LL +         None | Some(_) => todo!(),
 LL ~     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/error-codes/E0004.stderr b/tests/ui/error-codes/E0004.stderr
index ced478d65ea..17e2caa866b 100644
--- a/tests/ui/error-codes/E0004.stderr
+++ b/tests/ui/error-codes/E0004.stderr
@@ -18,6 +18,6 @@ LL ~         Terminator::TalkToMyHand => {},
 LL +         Terminator::HastaLaVistaBaby => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/error-codes/E0005.stderr b/tests/ui/error-codes/E0005.stderr
index 4692b66413d..4be37e2e454 100644
--- a/tests/ui/error-codes/E0005.stderr
+++ b/tests/ui/error-codes/E0005.stderr
@@ -12,6 +12,6 @@ help: you might want to use `let else` to handle the variant that isn't matched
 LL |     let Some(y) = x else { todo!() };
    |                     ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/error-codes/E0013.stderr b/tests/ui/error-codes/E0013.stderr
index dc22053a638..b07c8bdb700 100644
--- a/tests/ui/error-codes/E0013.stderr
+++ b/tests/ui/error-codes/E0013.stderr
@@ -6,6 +6,6 @@ LL | const Y: i32 = X;
    |
    = help: consider extracting the value of the `static` to a `const`, and referring to that
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0013`.
diff --git a/tests/ui/error-codes/E0015.stderr b/tests/ui/error-codes/E0015.stderr
index ec1ce47b2ce..9d892a3e098 100644
--- a/tests/ui/error-codes/E0015.stderr
+++ b/tests/ui/error-codes/E0015.stderr
@@ -6,6 +6,6 @@ LL | const FOO: Option<u8> = create_some();
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/error-codes/E0025.stderr b/tests/ui/error-codes/E0025.stderr
index dfec6d0276a..03347538a7a 100644
--- a/tests/ui/error-codes/E0025.stderr
+++ b/tests/ui/error-codes/E0025.stderr
@@ -6,6 +6,6 @@ LL |     let Foo { a: x, a: y, b: 0 } = x;
    |               |
    |               first use of `a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0025`.
diff --git a/tests/ui/error-codes/E0026-teach.stderr b/tests/ui/error-codes/E0026-teach.stderr
index 3d460490eb3..a496a7bdec7 100644
--- a/tests/ui/error-codes/E0026-teach.stderr
+++ b/tests/ui/error-codes/E0026-teach.stderr
@@ -8,6 +8,6 @@ LL |         Thing { x, y, z } => {}
            
            If you are using shorthand field patterns but want to refer to the struct field by a different name, you should rename it explicitly.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0026`.
diff --git a/tests/ui/error-codes/E0026.stderr b/tests/ui/error-codes/E0026.stderr
index 031481812d0..4d0dfbbf179 100644
--- a/tests/ui/error-codes/E0026.stderr
+++ b/tests/ui/error-codes/E0026.stderr
@@ -4,6 +4,6 @@ error[E0026]: struct `Thing` does not have a field named `z`
 LL |         Thing { x, y, z } => {}
    |                       ^ struct `Thing` does not have this field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0026`.
diff --git a/tests/ui/error-codes/E0029-teach.stderr b/tests/ui/error-codes/E0029-teach.stderr
index b89b2e7d11e..6b7d19f7b22 100644
--- a/tests/ui/error-codes/E0029-teach.stderr
+++ b/tests/ui/error-codes/E0029-teach.stderr
@@ -9,6 +9,6 @@ LL |         "hello" ..= "world" => {}
    |
    = note: In a match expression, only numbers and characters can be matched against a range. This is because the compiler checks that the range is non-empty at compile-time, and is unable to evaluate arbitrary comparison functions. If you want to capture values of an orderable type between two end-points, you can use a guard.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0029`.
diff --git a/tests/ui/error-codes/E0029.stderr b/tests/ui/error-codes/E0029.stderr
index f7250b39d3f..d596553dc53 100644
--- a/tests/ui/error-codes/E0029.stderr
+++ b/tests/ui/error-codes/E0029.stderr
@@ -7,6 +7,6 @@ LL |         "hello" ..= "world" => {}
    |         |           this is of type `&'static str` but it should be `char` or numeric
    |         this is of type `&'static str` but it should be `char` or numeric
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0029`.
diff --git a/tests/ui/error-codes/E0030-teach.stderr b/tests/ui/error-codes/E0030-teach.stderr
index 9435cb204bd..36200d2b86a 100644
--- a/tests/ui/error-codes/E0030-teach.stderr
+++ b/tests/ui/error-codes/E0030-teach.stderr
@@ -6,6 +6,6 @@ LL |         1000 ..= 5 => {}
    |
    = note: When matching against a range, the compiler verifies that the range is non-empty. Range patterns include both end-points, so this is equivalent to requiring the start of the range to be less than or equal to the end of the range.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0030`.
diff --git a/tests/ui/error-codes/E0030.stderr b/tests/ui/error-codes/E0030.stderr
index 1aeca291678..4e9378dfe1d 100644
--- a/tests/ui/error-codes/E0030.stderr
+++ b/tests/ui/error-codes/E0030.stderr
@@ -4,6 +4,6 @@ error[E0030]: lower range bound must be less than or equal to upper
 LL |         1000 ..= 5 => {}
    |         ^^^^^^^^^^ lower bound larger than upper bound
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0030`.
diff --git a/tests/ui/error-codes/E0033-teach.stderr b/tests/ui/error-codes/E0033-teach.stderr
index 31bc6719a56..303c2934428 100644
--- a/tests/ui/error-codes/E0033-teach.stderr
+++ b/tests/ui/error-codes/E0033-teach.stderr
@@ -8,6 +8,6 @@ LL |     let &invalid = trait_obj;
            
            You can read more about trait objects in the Trait Objects section of the Reference: https://doc.rust-lang.org/reference/types.html#trait-objects
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0033`.
diff --git a/tests/ui/error-codes/E0033.stderr b/tests/ui/error-codes/E0033.stderr
index ab2e780ee62..b091ad21720 100644
--- a/tests/ui/error-codes/E0033.stderr
+++ b/tests/ui/error-codes/E0033.stderr
@@ -4,6 +4,6 @@ error[E0033]: type `&dyn SomeTrait` cannot be dereferenced
 LL |     let &invalid = trait_obj;
    |         ^^^^^^^^ type `&dyn SomeTrait` cannot be dereferenced
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0033`.
diff --git a/tests/ui/error-codes/E0034.stderr b/tests/ui/error-codes/E0034.stderr
index da6f221881c..48b8efcf8a2 100644
--- a/tests/ui/error-codes/E0034.stderr
+++ b/tests/ui/error-codes/E0034.stderr
@@ -21,6 +21,6 @@ LL |     <Test as Trait1>::foo()
 LL |     <Test as Trait2>::foo()
    |     ~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/error-codes/E0038.stderr b/tests/ui/error-codes/E0038.stderr
index 3773d6f5234..99130396e02 100644
--- a/tests/ui/error-codes/E0038.stderr
+++ b/tests/ui/error-codes/E0038.stderr
@@ -13,6 +13,6 @@ LL |     fn foo(&self) -> Self;
    |                      ^^^^ ...because method `foo` references the `Self` type in its return type
    = help: consider moving `foo` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/error-codes/E0040.stderr b/tests/ui/error-codes/E0040.stderr
index 839be79d28d..00cccb07c0f 100644
--- a/tests/ui/error-codes/E0040.stderr
+++ b/tests/ui/error-codes/E0040.stderr
@@ -9,6 +9,6 @@ help: consider using `drop` function
 LL |     drop(x);
    |     +++++ ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0040`.
diff --git a/tests/ui/error-codes/E0044.stderr b/tests/ui/error-codes/E0044.stderr
index e889c167b98..e38959fda06 100644
--- a/tests/ui/error-codes/E0044.stderr
+++ b/tests/ui/error-codes/E0044.stderr
@@ -6,6 +6,6 @@ LL |     fn sqrt<T>(f: T) -> T;
    |
    = help: replace the type parameters with concrete types like `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0044`.
diff --git a/tests/ui/error-codes/E0045.stderr b/tests/ui/error-codes/E0045.stderr
index fcc613b11b8..25b2f2654da 100644
--- a/tests/ui/error-codes/E0045.stderr
+++ b/tests/ui/error-codes/E0045.stderr
@@ -4,6 +4,6 @@ error[E0045]: C-variadic function must have a compatible calling convention, lik
 LL | extern "Rust" { fn foo(x: u8, ...); }
    |                 ^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0045`.
diff --git a/tests/ui/error-codes/E0054.stderr b/tests/ui/error-codes/E0054.stderr
index 0a4adabbaf6..be35242ad72 100644
--- a/tests/ui/error-codes/E0054.stderr
+++ b/tests/ui/error-codes/E0054.stderr
@@ -9,6 +9,6 @@ help: compare with zero instead
 LL |     let x_is_nonzero = x != 0;
    |                          ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0054`.
diff --git a/tests/ui/error-codes/E0055.stderr b/tests/ui/error-codes/E0055.stderr
index a52c9096235..5cdc8b99469 100644
--- a/tests/ui/error-codes/E0055.stderr
+++ b/tests/ui/error-codes/E0055.stderr
@@ -6,6 +6,6 @@ LL |     ref_foo.foo();
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "8"]` attribute to your crate (`E0055`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0055`.
diff --git a/tests/ui/error-codes/E0059.stderr b/tests/ui/error-codes/E0059.stderr
index 4f6abb22ab2..a7591d2b04b 100644
--- a/tests/ui/error-codes/E0059.stderr
+++ b/tests/ui/error-codes/E0059.stderr
@@ -7,6 +7,6 @@ LL | fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0059`.
diff --git a/tests/ui/error-codes/E0060.stderr b/tests/ui/error-codes/E0060.stderr
index 934a18d896d..88c1f1bbb2a 100644
--- a/tests/ui/error-codes/E0060.stderr
+++ b/tests/ui/error-codes/E0060.stderr
@@ -14,6 +14,6 @@ help: provide the argument
 LL |     unsafe { printf(/* *const u8 */); }
    |                    ~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0060`.
diff --git a/tests/ui/error-codes/E0062.stderr b/tests/ui/error-codes/E0062.stderr
index a3e14099507..87c1c595e01 100644
--- a/tests/ui/error-codes/E0062.stderr
+++ b/tests/ui/error-codes/E0062.stderr
@@ -6,6 +6,6 @@ LL |         x: 0,
 LL |         x: 0,
    |         ^ used more than once
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0062`.
diff --git a/tests/ui/error-codes/E0069.stderr b/tests/ui/error-codes/E0069.stderr
index ff9bbe01dd5..20ff8c258a0 100644
--- a/tests/ui/error-codes/E0069.stderr
+++ b/tests/ui/error-codes/E0069.stderr
@@ -6,6 +6,6 @@ LL | fn foo() -> u8 {
 LL |     return;
    |     ^^^^^^ return type is not `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0069`.
diff --git a/tests/ui/error-codes/E0071.stderr b/tests/ui/error-codes/E0071.stderr
index 7bd4ddaf26b..bbd49f43b20 100644
--- a/tests/ui/error-codes/E0071.stderr
+++ b/tests/ui/error-codes/E0071.stderr
@@ -4,6 +4,6 @@ error[E0071]: expected struct, variant or union type, found `Foo`
 LL |     let u = FooAlias { value: 0 };
    |             ^^^^^^^^ not a struct
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0071`.
diff --git a/tests/ui/error-codes/E0075.stderr b/tests/ui/error-codes/E0075.stderr
index 3f927726a03..43e9971e309 100644
--- a/tests/ui/error-codes/E0075.stderr
+++ b/tests/ui/error-codes/E0075.stderr
@@ -4,6 +4,6 @@ error[E0075]: SIMD vector cannot be empty
 LL | struct Bad;
    | ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0075`.
diff --git a/tests/ui/error-codes/E0076.stderr b/tests/ui/error-codes/E0076.stderr
index 7d4ff879816..ea3bbf09497 100644
--- a/tests/ui/error-codes/E0076.stderr
+++ b/tests/ui/error-codes/E0076.stderr
@@ -4,6 +4,6 @@ error[E0076]: SIMD vector should be homogeneous
 LL | struct Bad(u16, u32, u32);
    | ^^^^^^^^^^ SIMD elements must have the same type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0076`.
diff --git a/tests/ui/error-codes/E0077.stderr b/tests/ui/error-codes/E0077.stderr
index 9a84b2ec406..aae4b3f2c29 100644
--- a/tests/ui/error-codes/E0077.stderr
+++ b/tests/ui/error-codes/E0077.stderr
@@ -4,6 +4,6 @@ error[E0077]: SIMD vector element type should be a primitive scalar (integer/flo
 LL | struct Bad(String);
    | ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0077`.
diff --git a/tests/ui/error-codes/E0084.stderr b/tests/ui/error-codes/E0084.stderr
index e1bda22b8d1..f1fbe6c2532 100644
--- a/tests/ui/error-codes/E0084.stderr
+++ b/tests/ui/error-codes/E0084.stderr
@@ -6,6 +6,6 @@ LL | #[repr(i32)]
 LL | enum Foo {}
    | -------- zero-variant enum
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0084`.
diff --git a/tests/ui/error-codes/E0092.stderr b/tests/ui/error-codes/E0092.stderr
index 2d590a8e1d7..4ff2e6f077d 100644
--- a/tests/ui/error-codes/E0092.stderr
+++ b/tests/ui/error-codes/E0092.stderr
@@ -4,6 +4,6 @@ error[E0092]: unrecognized atomic operation function: `foo`
 LL |     fn atomic_foo();
    |     ^^^^^^^^^^^^^^^^ unrecognized atomic operation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0092`.
diff --git a/tests/ui/error-codes/E0093.stderr b/tests/ui/error-codes/E0093.stderr
index cb0305593a7..387e0c55d4d 100644
--- a/tests/ui/error-codes/E0093.stderr
+++ b/tests/ui/error-codes/E0093.stderr
@@ -4,6 +4,6 @@ error[E0093]: unrecognized intrinsic function: `foo`
 LL |     fn foo();
    |     ^^^^^^^^^ unrecognized intrinsic
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0093`.
diff --git a/tests/ui/error-codes/E0094.stderr b/tests/ui/error-codes/E0094.stderr
index 531cd4c784d..1bad5bd950e 100644
--- a/tests/ui/error-codes/E0094.stderr
+++ b/tests/ui/error-codes/E0094.stderr
@@ -4,6 +4,6 @@ error[E0094]: intrinsic has wrong number of type parameters: found 2, expected 1
 LL |     fn size_of<T, U>() -> usize;
    |               ^^^^^^ expected 1 type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0094`.
diff --git a/tests/ui/error-codes/E0109.stderr b/tests/ui/error-codes/E0109.stderr
index 8f4cb86de99..ab0d4aac743 100644
--- a/tests/ui/error-codes/E0109.stderr
+++ b/tests/ui/error-codes/E0109.stderr
@@ -12,6 +12,6 @@ LL - type X = u32<i32>;
 LL + type X = u32;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/error-codes/E0110.stderr b/tests/ui/error-codes/E0110.stderr
index 4ce2a0a410c..2f51329ba73 100644
--- a/tests/ui/error-codes/E0110.stderr
+++ b/tests/ui/error-codes/E0110.stderr
@@ -12,6 +12,6 @@ LL - type X = u32<'static>;
 LL + type X = u32;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/error-codes/E0116.stderr b/tests/ui/error-codes/E0116.stderr
index 8a027686760..bf215435ba6 100644
--- a/tests/ui/error-codes/E0116.stderr
+++ b/tests/ui/error-codes/E0116.stderr
@@ -6,6 +6,6 @@ LL | impl Vec<u8> {}
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0116`.
diff --git a/tests/ui/error-codes/E0118.stderr b/tests/ui/error-codes/E0118.stderr
index 442f8a4f870..0d837aa59ff 100644
--- a/tests/ui/error-codes/E0118.stderr
+++ b/tests/ui/error-codes/E0118.stderr
@@ -6,6 +6,6 @@ LL | impl<T> T {
    |
    = note: either implement a trait on it or create a newtype to wrap it instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0118`.
diff --git a/tests/ui/error-codes/E0119.stderr b/tests/ui/error-codes/E0119.stderr
index e08a2c7fcbb..838dba081b9 100644
--- a/tests/ui/error-codes/E0119.stderr
+++ b/tests/ui/error-codes/E0119.stderr
@@ -7,6 +7,6 @@ LL | impl<T> MyTrait for T {
 LL | impl MyTrait for Foo {
    | ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/error-codes/E0120.stderr b/tests/ui/error-codes/E0120.stderr
index 75778f1f94a..aef777ad060 100644
--- a/tests/ui/error-codes/E0120.stderr
+++ b/tests/ui/error-codes/E0120.stderr
@@ -4,6 +4,6 @@ error[E0120]: the `Drop` trait may only be implemented for local structs, enums,
 LL | impl Drop for dyn MyTrait {
    |               ^^^^^^^^^^^ must be a struct, enum, or union in the current crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0120`.
diff --git a/tests/ui/error-codes/E0124.stderr b/tests/ui/error-codes/E0124.stderr
index 73819a89d75..f33495806e1 100644
--- a/tests/ui/error-codes/E0124.stderr
+++ b/tests/ui/error-codes/E0124.stderr
@@ -6,6 +6,6 @@ LL |     field1: i32,
 LL |     field1: i32,
    |     ^^^^^^^^^^^ field already declared
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0124`.
diff --git a/tests/ui/error-codes/E0128.stderr b/tests/ui/error-codes/E0128.stderr
index eb66d46936a..c1ccb4c9e74 100644
--- a/tests/ui/error-codes/E0128.stderr
+++ b/tests/ui/error-codes/E0128.stderr
@@ -4,6 +4,6 @@ error[E0128]: generic parameters with a default cannot use forward declared iden
 LL | struct Foo<T=U, U=()> {
    |              ^ defaulted generic parameters cannot be forward declared
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0128`.
diff --git a/tests/ui/error-codes/E0130.stderr b/tests/ui/error-codes/E0130.stderr
index a45571f40a1..a31517218b4 100644
--- a/tests/ui/error-codes/E0130.stderr
+++ b/tests/ui/error-codes/E0130.stderr
@@ -4,6 +4,6 @@ error[E0130]: patterns aren't allowed in foreign function declarations
 LL |     fn foo((a, b): (u32, u32));
    |            ^^^^^^ pattern not allowed in foreign function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0130`.
diff --git a/tests/ui/error-codes/E0131.stderr b/tests/ui/error-codes/E0131.stderr
index 4467e19e95d..3a485cdf3fd 100644
--- a/tests/ui/error-codes/E0131.stderr
+++ b/tests/ui/error-codes/E0131.stderr
@@ -4,6 +4,6 @@ error[E0131]: `main` function is not allowed to have generic parameters
 LL | fn main<T>() {
    |        ^^^ `main` cannot have generic parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0131`.
diff --git a/tests/ui/error-codes/E0132.stderr b/tests/ui/error-codes/E0132.stderr
index d4ddc07b521..b1990afa3ae 100644
--- a/tests/ui/error-codes/E0132.stderr
+++ b/tests/ui/error-codes/E0132.stderr
@@ -4,6 +4,6 @@ error[E0132]: `#[start]` function is not allowed to have type parameters
 LL | fn f< T >() {}
    |     ^^^^^ `#[start]` function cannot have type parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0132`.
diff --git a/tests/ui/error-codes/E0133.mir.stderr b/tests/ui/error-codes/E0133.mir.stderr
index b11d5e2c2fc..f8703ef0633 100644
--- a/tests/ui/error-codes/E0133.mir.stderr
+++ b/tests/ui/error-codes/E0133.mir.stderr
@@ -6,6 +6,6 @@ LL |     f();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/error-codes/E0133.thir.stderr b/tests/ui/error-codes/E0133.thir.stderr
index f1d7aba2aa3..fd4d42bcb8b 100644
--- a/tests/ui/error-codes/E0133.thir.stderr
+++ b/tests/ui/error-codes/E0133.thir.stderr
@@ -6,6 +6,6 @@ LL |     f();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/error-codes/E0138.stderr b/tests/ui/error-codes/E0138.stderr
index fa8c3942732..04877ab4082 100644
--- a/tests/ui/error-codes/E0138.stderr
+++ b/tests/ui/error-codes/E0138.stderr
@@ -7,6 +7,6 @@ LL | fn foo(argc: isize, argv: *const *const u8) -> isize { 0 }
 LL | fn f(argc: isize, argv: *const *const u8) -> isize { 0 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ multiple `start` functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0138`.
diff --git a/tests/ui/error-codes/E0152.stderr b/tests/ui/error-codes/E0152.stderr
index 29f7e4ad683..816ba2d569b 100644
--- a/tests/ui/error-codes/E0152.stderr
+++ b/tests/ui/error-codes/E0152.stderr
@@ -8,6 +8,6 @@ LL | struct Foo<T>(T);
    = note: first definition in `alloc` loaded from SYSROOT/liballoc-*.rlib
    = note: second definition in the local crate (`E0152`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0152`.
diff --git a/tests/ui/error-codes/E0161.base.stderr b/tests/ui/error-codes/E0161.base.stderr
index ae82e6702e6..d80de66b247 100644
--- a/tests/ui/error-codes/E0161.base.stderr
+++ b/tests/ui/error-codes/E0161.base.stderr
@@ -4,6 +4,6 @@ error[E0161]: cannot move a value of type `dyn Bar`
 LL |     x.f();
    |     ^ the size of `dyn Bar` cannot be statically determined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0161`.
diff --git a/tests/ui/error-codes/E0164.stderr b/tests/ui/error-codes/E0164.stderr
index 5a80d6ec31a..1ed5b0a8f07 100644
--- a/tests/ui/error-codes/E0164.stderr
+++ b/tests/ui/error-codes/E0164.stderr
@@ -4,6 +4,6 @@ error[E0164]: expected tuple struct or tuple variant, found associated constant
 LL |         Foo::B(i) => i,
    |         ^^^^^^^^^ not a tuple struct or tuple variant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0164`.
diff --git a/tests/ui/error-codes/E0184.stderr b/tests/ui/error-codes/E0184.stderr
index 52f1f30a408..625c6685a61 100644
--- a/tests/ui/error-codes/E0184.stderr
+++ b/tests/ui/error-codes/E0184.stderr
@@ -6,6 +6,6 @@ LL | #[derive(Copy)]
    |
    = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0184`.
diff --git a/tests/ui/error-codes/E0185.stderr b/tests/ui/error-codes/E0185.stderr
index 8a99c0688e3..40d6ad3f2bd 100644
--- a/tests/ui/error-codes/E0185.stderr
+++ b/tests/ui/error-codes/E0185.stderr
@@ -7,6 +7,6 @@ LL |     fn foo();
 LL |     fn foo(&self) {}
    |     ^^^^^^^^^^^^^ `&self` used in impl
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0185`.
diff --git a/tests/ui/error-codes/E0186.stderr b/tests/ui/error-codes/E0186.stderr
index 8971d61fc75..59b210927de 100644
--- a/tests/ui/error-codes/E0186.stderr
+++ b/tests/ui/error-codes/E0186.stderr
@@ -7,6 +7,6 @@ LL |     fn foo(&self);
 LL |     fn foo() {}
    |     ^^^^^^^^ expected `&self` in impl
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0186`.
diff --git a/tests/ui/error-codes/E0191.stderr b/tests/ui/error-codes/E0191.stderr
index 57eda4785a9..63974fd6cbb 100644
--- a/tests/ui/error-codes/E0191.stderr
+++ b/tests/ui/error-codes/E0191.stderr
@@ -7,6 +7,6 @@ LL |     type Bar;
 LL | type Foo = dyn Trait;
    |                ^^^^^ help: specify the associated type: `Trait<Bar = Type>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0191`.
diff --git a/tests/ui/error-codes/E0194.stderr b/tests/ui/error-codes/E0194.stderr
index f2c908eea0b..25fc1a3b79f 100644
--- a/tests/ui/error-codes/E0194.stderr
+++ b/tests/ui/error-codes/E0194.stderr
@@ -7,6 +7,6 @@ LL |     fn do_something(&self) -> T;
 LL |     fn do_something_else<T: Clone>(&self, bar: T);
    |                          ^ already used
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0403`.
diff --git a/tests/ui/error-codes/E0195.stderr b/tests/ui/error-codes/E0195.stderr
index 6eaa1750ee3..b88064b7f90 100644
--- a/tests/ui/error-codes/E0195.stderr
+++ b/tests/ui/error-codes/E0195.stderr
@@ -7,6 +7,6 @@ LL |     fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
 LL |     fn bar<'a,'b>(x: &'a str, y: &'b str) {
    |           ^^^^^^^ lifetimes do not match method in trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0195`.
diff --git a/tests/ui/error-codes/E0197.stderr b/tests/ui/error-codes/E0197.stderr
index 35e1042649e..c06777396e8 100644
--- a/tests/ui/error-codes/E0197.stderr
+++ b/tests/ui/error-codes/E0197.stderr
@@ -6,6 +6,6 @@ LL | unsafe impl Foo { }
    | |
    | unsafe because of this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0197`.
diff --git a/tests/ui/error-codes/E0198.stderr b/tests/ui/error-codes/E0198.stderr
index bb2efefb427..65b4f5364c2 100644
--- a/tests/ui/error-codes/E0198.stderr
+++ b/tests/ui/error-codes/E0198.stderr
@@ -7,6 +7,6 @@ LL | unsafe impl !Send for Foo { }
    | |           negative because of this
    | unsafe because of this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0198`.
diff --git a/tests/ui/error-codes/E0199.stderr b/tests/ui/error-codes/E0199.stderr
index 68c308b15cc..a61a18d170b 100644
--- a/tests/ui/error-codes/E0199.stderr
+++ b/tests/ui/error-codes/E0199.stderr
@@ -10,6 +10,6 @@ LL - unsafe impl Bar for Foo { }
 LL + impl Bar for Foo { }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0199`.
diff --git a/tests/ui/error-codes/E0200.stderr b/tests/ui/error-codes/E0200.stderr
index c70a2d4f3d1..fe8353deed1 100644
--- a/tests/ui/error-codes/E0200.stderr
+++ b/tests/ui/error-codes/E0200.stderr
@@ -10,6 +10,6 @@ help: add `unsafe` to this trait implementation
 LL | unsafe impl Bar for Foo { }
    | ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0200`.
diff --git a/tests/ui/error-codes/E0206.stderr b/tests/ui/error-codes/E0206.stderr
index 60d8d7bfe98..d19f2e33ac9 100644
--- a/tests/ui/error-codes/E0206.stderr
+++ b/tests/ui/error-codes/E0206.stderr
@@ -4,6 +4,6 @@ error[E0206]: the trait `Copy` cannot be implemented for this type
 LL | impl Copy for &'static mut Bar { }
    |               ^^^^^^^^^^^^^^^^ type is not a structure or enumeration
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0206`.
diff --git a/tests/ui/error-codes/E0207.stderr b/tests/ui/error-codes/E0207.stderr
index 5ef51ed8692..01d7c418544 100644
--- a/tests/ui/error-codes/E0207.stderr
+++ b/tests/ui/error-codes/E0207.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T: Default> Foo {
    |      ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/error-codes/E0208.stderr b/tests/ui/error-codes/E0208.stderr
index 2c7072a7e76..77b6ceae4dc 100644
--- a/tests/ui/error-codes/E0208.stderr
+++ b/tests/ui/error-codes/E0208.stderr
@@ -4,5 +4,5 @@ error: [+, o]
 LL | struct Foo<'a, T> {
    | ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0214.stderr b/tests/ui/error-codes/E0214.stderr
index e0179aac27f..76b11f30996 100644
--- a/tests/ui/error-codes/E0214.stderr
+++ b/tests/ui/error-codes/E0214.stderr
@@ -9,6 +9,6 @@ help: use angle brackets instead
 LL |     let v: Vec<&str> = vec!["foo"];
    |               ~    ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0214`.
diff --git a/tests/ui/error-codes/E0223.stderr b/tests/ui/error-codes/E0223.stderr
index 1299ba5f50c..e985a4c9bf0 100644
--- a/tests/ui/error-codes/E0223.stderr
+++ b/tests/ui/error-codes/E0223.stderr
@@ -4,6 +4,6 @@ error[E0223]: ambiguous associated type
 LL |     let foo: MyTrait::X;
    |              ^^^^^^^^^^ help: use fully-qualified syntax: `<MyStruct as MyTrait>::X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/error-codes/E0227.stderr b/tests/ui/error-codes/E0227.stderr
index 26de5b4c400..c77a2e98af7 100644
--- a/tests/ui/error-codes/E0227.stderr
+++ b/tests/ui/error-codes/E0227.stderr
@@ -4,6 +4,6 @@ error[E0227]: ambiguous lifetime bound, explicit lifetime bound required
 LL |     baz: dyn FooBar<'foo, 'bar>,
    |          ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0227`.
diff --git a/tests/ui/error-codes/E0229.stderr b/tests/ui/error-codes/E0229.stderr
index 46793314bf9..e981fb91ce8 100644
--- a/tests/ui/error-codes/E0229.stderr
+++ b/tests/ui/error-codes/E0229.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL | fn baz<I>(x: &<I as Foo<A=Bar>>::A) {}
    |                         ^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/error-codes/E0252.stderr b/tests/ui/error-codes/E0252.stderr
index 2722dfe5e05..efbb9ec96de 100644
--- a/tests/ui/error-codes/E0252.stderr
+++ b/tests/ui/error-codes/E0252.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use bar::baz as other_baz;
    |     ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/error-codes/E0253.stderr b/tests/ui/error-codes/E0253.stderr
index 8f21a0aaba5..4ee36b70fe5 100644
--- a/tests/ui/error-codes/E0253.stderr
+++ b/tests/ui/error-codes/E0253.stderr
@@ -4,6 +4,6 @@ error[E0253]: `do_something` is not directly importable
 LL | use foo::MyTrait::do_something;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot be imported directly
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0253`.
diff --git a/tests/ui/error-codes/E0254.stderr b/tests/ui/error-codes/E0254.stderr
index b098f8e1a7f..d89497b2804 100644
--- a/tests/ui/error-codes/E0254.stderr
+++ b/tests/ui/error-codes/E0254.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | use foo::alloc as other_alloc;
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0254`.
diff --git a/tests/ui/error-codes/E0255.stderr b/tests/ui/error-codes/E0255.stderr
index 352c5ba5be0..e5f908217e1 100644
--- a/tests/ui/error-codes/E0255.stderr
+++ b/tests/ui/error-codes/E0255.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | use bar::foo as other_foo;
    |     ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/error-codes/E0259.stderr b/tests/ui/error-codes/E0259.stderr
index 06cbc5b4fb5..6e086268fc6 100644
--- a/tests/ui/error-codes/E0259.stderr
+++ b/tests/ui/error-codes/E0259.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate libc as other_alloc;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/error-codes/E0260.stderr b/tests/ui/error-codes/E0260.stderr
index 2d3305bd15b..35698c65359 100644
--- a/tests/ui/error-codes/E0260.stderr
+++ b/tests/ui/error-codes/E0260.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate alloc as other_alloc;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0260`.
diff --git a/tests/ui/error-codes/E0262.stderr b/tests/ui/error-codes/E0262.stderr
index ad90b717126..092db22ed5e 100644
--- a/tests/ui/error-codes/E0262.stderr
+++ b/tests/ui/error-codes/E0262.stderr
@@ -4,6 +4,6 @@ error[E0262]: invalid lifetime parameter name: `'static`
 LL | fn foo<'static>(x: &'static str) { }
    |        ^^^^^^^ 'static is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0262`.
diff --git a/tests/ui/error-codes/E0263.stderr b/tests/ui/error-codes/E0263.stderr
index e3f9aea296a..dcf57d8e3bc 100644
--- a/tests/ui/error-codes/E0263.stderr
+++ b/tests/ui/error-codes/E0263.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a, 'b, 'a>(x: &'a str, y: &'b str) {
    |        |
    |        first use of `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0403`.
diff --git a/tests/ui/error-codes/E0264.stderr b/tests/ui/error-codes/E0264.stderr
index e8e35a12cbb..14a4ffbe316 100644
--- a/tests/ui/error-codes/E0264.stderr
+++ b/tests/ui/error-codes/E0264.stderr
@@ -4,6 +4,6 @@ error[E0264]: unknown external lang item: `cake`
 LL |     fn cake();
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0264`.
diff --git a/tests/ui/error-codes/E0267.stderr b/tests/ui/error-codes/E0267.stderr
index 1f8657373ef..81f9005d6e6 100644
--- a/tests/ui/error-codes/E0267.stderr
+++ b/tests/ui/error-codes/E0267.stderr
@@ -6,6 +6,6 @@ LL |     let w = || { break; };
    |             |
    |             enclosing closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0267`.
diff --git a/tests/ui/error-codes/E0268.stderr b/tests/ui/error-codes/E0268.stderr
index 6422e8a9490..8d03103dafc 100644
--- a/tests/ui/error-codes/E0268.stderr
+++ b/tests/ui/error-codes/E0268.stderr
@@ -4,6 +4,6 @@ error[E0268]: `break` outside of a loop or labeled block
 LL |     break;
    |     ^^^^^ cannot `break` outside of a loop or labeled block
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0268`.
diff --git a/tests/ui/error-codes/E0271.stderr b/tests/ui/error-codes/E0271.stderr
index 1e2f4383459..0e456eb0d50 100644
--- a/tests/ui/error-codes/E0271.stderr
+++ b/tests/ui/error-codes/E0271.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `foo`
 LL | fn foo<T>(t: T) where T: Trait<AssociatedType=u32> {
    |                                ^^^^^^^^^^^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/error-codes/E0275.stderr b/tests/ui/error-codes/E0275.stderr
index c702c3790a7..b5075408340 100644
--- a/tests/ui/error-codes/E0275.stderr
+++ b/tests/ui/error-codes/E0275.stderr
@@ -13,6 +13,6 @@ LL | impl<T> Foo for T where Bar<T>: Foo {}
    = note: 126 redundant requirements hidden
    = note: required for `Bar<T>` to implement `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/error-codes/E0276.stderr b/tests/ui/error-codes/E0276.stderr
index 1013f041bbe..eb004370a1c 100644
--- a/tests/ui/error-codes/E0276.stderr
+++ b/tests/ui/error-codes/E0276.stderr
@@ -7,6 +7,6 @@ LL |     fn foo<T>(x: T);
 LL |     fn foo<T>(x: T) where T: Copy {}
    |                              ^^^^ impl has extra requirement `T: Copy`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/error-codes/E0277-2.stderr b/tests/ui/error-codes/E0277-2.stderr
index a2abf37931a..9a262f75590 100644
--- a/tests/ui/error-codes/E0277-2.stderr
+++ b/tests/ui/error-codes/E0277-2.stderr
@@ -26,6 +26,6 @@ note: required by a bound in `is_send`
 LL | fn is_send<T: Send>() { }
    |               ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/error-codes/E0277-3.stderr b/tests/ui/error-codes/E0277-3.stderr
index 0d4782935df..6cdfaa04f4a 100644
--- a/tests/ui/error-codes/E0277-3.stderr
+++ b/tests/ui/error-codes/E0277-3.stderr
@@ -18,6 +18,6 @@ LL + #[derive(PartialEq)]
 LL | struct S;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/error-codes/E0282.stderr b/tests/ui/error-codes/E0282.stderr
index 58332454a37..295e8480349 100644
--- a/tests/ui/error-codes/E0282.stderr
+++ b/tests/ui/error-codes/E0282.stderr
@@ -9,6 +9,6 @@ help: consider giving `x` an explicit type
 LL |     let x: /* Type */;
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/error-codes/E0297.stderr b/tests/ui/error-codes/E0297.stderr
index 293028f5f68..3bfe8a66833 100644
--- a/tests/ui/error-codes/E0297.stderr
+++ b/tests/ui/error-codes/E0297.stderr
@@ -6,6 +6,6 @@ LL |     for Some(x) in xs {}
    |
    = note: the matched value is of type `Option<i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/error-codes/E0308-2.stderr b/tests/ui/error-codes/E0308-2.stderr
index 3a8a81a73a6..b1497791797 100644
--- a/tests/ui/error-codes/E0308-2.stderr
+++ b/tests/ui/error-codes/E0308-2.stderr
@@ -13,6 +13,6 @@ LL | impl Eq for &dyn DynEq {}
    |             ^
    = note: ...does not necessarily outlive the static lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/error-codes/E0308-4.stderr b/tests/ui/error-codes/E0308-4.stderr
index 39c06763737..9f33220a591 100644
--- a/tests/ui/error-codes/E0308-4.stderr
+++ b/tests/ui/error-codes/E0308-4.stderr
@@ -8,6 +8,6 @@ LL |         0u8..=3i8 => (),
    |         |
    |         this is of type `u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/error-codes/E0308.stderr b/tests/ui/error-codes/E0308.stderr
index 141abed6032..bc6c5a632a1 100644
--- a/tests/ui/error-codes/E0308.stderr
+++ b/tests/ui/error-codes/E0308.stderr
@@ -7,6 +7,6 @@ LL |     fn size_of<T>();
    = note: expected signature `extern "rust-intrinsic" fn() -> usize`
               found signature `extern "rust-intrinsic" fn()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/error-codes/E0311.stderr b/tests/ui/error-codes/E0311.stderr
index 96546b83f2f..bac18596f3e 100644
--- a/tests/ui/error-codes/E0311.stderr
+++ b/tests/ui/error-codes/E0311.stderr
@@ -11,6 +11,6 @@ help: consider adding an explicit lifetime bound
 LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
    |                   +++  ++++      ++         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0311`.
diff --git a/tests/ui/error-codes/E0328.stderr b/tests/ui/error-codes/E0328.stderr
index 70e6baf69d3..1143c383414 100644
--- a/tests/ui/error-codes/E0328.stderr
+++ b/tests/ui/error-codes/E0328.stderr
@@ -4,6 +4,6 @@ error[E0328]: explicit impls for the `Unsize` trait are not permitted
 LL | impl<T> Unsize<T> for MyType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl of `Unsize` not allowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0328`.
diff --git a/tests/ui/error-codes/E0365.stderr b/tests/ui/error-codes/E0365.stderr
index 5bfcf1394d9..d6eb9d6c383 100644
--- a/tests/ui/error-codes/E0365.stderr
+++ b/tests/ui/error-codes/E0365.stderr
@@ -6,6 +6,6 @@ LL | pub use foo as foo2;
    |
    = note: consider declaring type or module `foo` with `pub`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0365`.
diff --git a/tests/ui/error-codes/E0370.stderr b/tests/ui/error-codes/E0370.stderr
index 7fb622ee80b..7bcd99b9578 100644
--- a/tests/ui/error-codes/E0370.stderr
+++ b/tests/ui/error-codes/E0370.stderr
@@ -6,6 +6,6 @@ LL |     Y,
    |
    = note: explicitly set `Y = -9223372036854775808` if that is desired outcome
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0370`.
diff --git a/tests/ui/error-codes/E0374.stderr b/tests/ui/error-codes/E0374.stderr
index 49ec0bce441..148fa1348ab 100644
--- a/tests/ui/error-codes/E0374.stderr
+++ b/tests/ui/error-codes/E0374.stderr
@@ -7,6 +7,6 @@ LL | |     where T: CoerceUnsized<U> {}
    |
    = note: expected a single field to be coerced, none found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0374`.
diff --git a/tests/ui/error-codes/E0375.stderr b/tests/ui/error-codes/E0375.stderr
index a68b3af5aaf..0a5e4128ae9 100644
--- a/tests/ui/error-codes/E0375.stderr
+++ b/tests/ui/error-codes/E0375.stderr
@@ -7,6 +7,6 @@ LL | impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
    = note: `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced
    = note: currently, 2 fields need coercions: `b` (`T` to `U`), `c` (`U` to `T`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0375`.
diff --git a/tests/ui/error-codes/E0376.stderr b/tests/ui/error-codes/E0376.stderr
index e91efb045c1..46668e05a42 100644
--- a/tests/ui/error-codes/E0376.stderr
+++ b/tests/ui/error-codes/E0376.stderr
@@ -4,6 +4,6 @@ error[E0376]: the trait `CoerceUnsized` may only be implemented for a coercion b
 LL | impl<T, U> CoerceUnsized<U> for Foo<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0376`.
diff --git a/tests/ui/error-codes/E0377.stderr b/tests/ui/error-codes/E0377.stderr
index 9cb11e5a3d3..5d710d8e152 100644
--- a/tests/ui/error-codes/E0377.stderr
+++ b/tests/ui/error-codes/E0377.stderr
@@ -6,6 +6,6 @@ LL | impl<T, U> CoerceUnsized<Bar<U>> for Foo<T> where T: CoerceUnsized<U> {}
    |
    = note: expected coercion between the same definition; expected `Foo`, found `Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0377`.
diff --git a/tests/ui/error-codes/E0389.stderr b/tests/ui/error-codes/E0389.stderr
index e4001856c38..156bff7f022 100644
--- a/tests/ui/error-codes/E0389.stderr
+++ b/tests/ui/error-codes/E0389.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     let fancy_ref = &mut (&mut fancy);
    |                      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/error-codes/E0392.stderr b/tests/ui/error-codes/E0392.stderr
index 622402999c3..ecbfd5584d5 100644
--- a/tests/ui/error-codes/E0392.stderr
+++ b/tests/ui/error-codes/E0392.stderr
@@ -7,6 +7,6 @@ LL | enum Foo<T> { Bar }
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
    = help: if you intended `T` to be a const parameter, use `const T: usize` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0392`.
diff --git a/tests/ui/error-codes/E0393.stderr b/tests/ui/error-codes/E0393.stderr
index d9f70b72930..4083fa23e87 100644
--- a/tests/ui/error-codes/E0393.stderr
+++ b/tests/ui/error-codes/E0393.stderr
@@ -9,6 +9,6 @@ LL | fn together_we_will_rule_the_galaxy(son: &dyn A) {}
    |
    = note: because of the default `Self` reference, type parameters must be specified on object types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0393`.
diff --git a/tests/ui/error-codes/E0396-fixed.stderr b/tests/ui/error-codes/E0396-fixed.stderr
index e77b2ce9a22..2f8ea7993f7 100644
--- a/tests/ui/error-codes/E0396-fixed.stderr
+++ b/tests/ui/error-codes/E0396-fixed.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | const VALUE: u8 = unsafe { *REG_ADDR };
    |                            ^^^^^^^^^ memory access failed: 0x5f3759df[noalloc] is a dangling pointer (it has no provenance)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/error-codes/E0403.stderr b/tests/ui/error-codes/E0403.stderr
index d76a58a7c80..02f255b7e46 100644
--- a/tests/ui/error-codes/E0403.stderr
+++ b/tests/ui/error-codes/E0403.stderr
@@ -6,6 +6,6 @@ LL | fn foo<T, T>(s: T, u: T) {}
    |        |
    |        first use of `T`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0403`.
diff --git a/tests/ui/error-codes/E0405.stderr b/tests/ui/error-codes/E0405.stderr
index a22afe6f3e8..1fb115c9e99 100644
--- a/tests/ui/error-codes/E0405.stderr
+++ b/tests/ui/error-codes/E0405.stderr
@@ -4,6 +4,6 @@ error[E0405]: cannot find trait `SomeTrait` in this scope
 LL | impl SomeTrait for Foo {}
    |      ^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/error-codes/E0407.stderr b/tests/ui/error-codes/E0407.stderr
index 6f6d1ff6a8f..889668f5892 100644
--- a/tests/ui/error-codes/E0407.stderr
+++ b/tests/ui/error-codes/E0407.stderr
@@ -7,6 +7,6 @@ LL |     fn b() {}
    |     |  help: there is an associated function with a similar name: `a`
    |     not a member of trait `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0407`.
diff --git a/tests/ui/error-codes/E0408.stderr b/tests/ui/error-codes/E0408.stderr
index 132a9432254..45ac480061f 100644
--- a/tests/ui/error-codes/E0408.stderr
+++ b/tests/ui/error-codes/E0408.stderr
@@ -6,6 +6,6 @@ LL |         Some(y) | None => {}
    |              |
    |              variable not in all patterns
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/error-codes/E0411.stderr b/tests/ui/error-codes/E0411.stderr
index 4c99f9fcbf1..16da10348a2 100644
--- a/tests/ui/error-codes/E0411.stderr
+++ b/tests/ui/error-codes/E0411.stderr
@@ -6,6 +6,6 @@ LL | fn main() {
 LL |     <Self>::foo;
    |      ^^^^ `Self` is only available in impls, traits, and type definitions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0411`.
diff --git a/tests/ui/error-codes/E0412.stderr b/tests/ui/error-codes/E0412.stderr
index 7bdaa180730..7c1172642fa 100644
--- a/tests/ui/error-codes/E0412.stderr
+++ b/tests/ui/error-codes/E0412.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Something` in this scope
 LL | impl Something {}
    |      ^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/error-codes/E0415.stderr b/tests/ui/error-codes/E0415.stderr
index c2b8fdc7c55..77e5752de81 100644
--- a/tests/ui/error-codes/E0415.stderr
+++ b/tests/ui/error-codes/E0415.stderr
@@ -4,6 +4,6 @@ error[E0415]: identifier `f` is bound more than once in this parameter list
 LL | fn foo(f: i32, f: i32) {}
    |                ^ used as parameter more than once
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0415`.
diff --git a/tests/ui/error-codes/E0416.stderr b/tests/ui/error-codes/E0416.stderr
index 78acac5c661..643b9908701 100644
--- a/tests/ui/error-codes/E0416.stderr
+++ b/tests/ui/error-codes/E0416.stderr
@@ -4,6 +4,6 @@ error[E0416]: identifier `x` is bound more than once in the same pattern
 LL |         (x, x) => {}
    |             ^ used in a pattern more than once
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0416`.
diff --git a/tests/ui/error-codes/E0425.stderr b/tests/ui/error-codes/E0425.stderr
index 9ef4608da7d..db78dc3f7ab 100644
--- a/tests/ui/error-codes/E0425.stderr
+++ b/tests/ui/error-codes/E0425.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `elf` in this scope
 LL |         elf;
    |         ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/error-codes/E0426.stderr b/tests/ui/error-codes/E0426.stderr
index 035f2eb86b9..3e03030dfc9 100644
--- a/tests/ui/error-codes/E0426.stderr
+++ b/tests/ui/error-codes/E0426.stderr
@@ -4,6 +4,6 @@ error[E0426]: use of undeclared label `'a`
 LL |         break 'a;
    |               ^^ undeclared label `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0426`.
diff --git a/tests/ui/error-codes/E0428.stderr b/tests/ui/error-codes/E0428.stderr
index 205bcf342f1..b5bb84e2e68 100644
--- a/tests/ui/error-codes/E0428.stderr
+++ b/tests/ui/error-codes/E0428.stderr
@@ -8,6 +8,6 @@ LL | struct Bar;
    |
    = note: `Bar` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/error-codes/E0429.stderr b/tests/ui/error-codes/E0429.stderr
index 08b99232ee2..d2d9ba209f7 100644
--- a/tests/ui/error-codes/E0429.stderr
+++ b/tests/ui/error-codes/E0429.stderr
@@ -14,6 +14,6 @@ help: alternatively, use the multi-path `use` syntax to import `self`
 LL | use std::fmt::{self};
    |               +    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0429`.
diff --git a/tests/ui/error-codes/E0431.stderr b/tests/ui/error-codes/E0431.stderr
index adfd2d923c7..f77c62bec68 100644
--- a/tests/ui/error-codes/E0431.stderr
+++ b/tests/ui/error-codes/E0431.stderr
@@ -4,6 +4,6 @@ error[E0431]: `self` import can only appear in an import list with a non-empty p
 LL | use {self};
    |      ^^^^ can only appear in an import list with a non-empty prefix
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0431`.
diff --git a/tests/ui/error-codes/E0432.stderr b/tests/ui/error-codes/E0432.stderr
index ed9536f164e..473e82f8634 100644
--- a/tests/ui/error-codes/E0432.stderr
+++ b/tests/ui/error-codes/E0432.stderr
@@ -6,6 +6,6 @@ LL | use something::Foo;
    |
    = help: consider adding `extern crate something` to use the `something` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/error-codes/E0433.stderr b/tests/ui/error-codes/E0433.stderr
index 265d8885c8d..1ac8c3ebc4d 100644
--- a/tests/ui/error-codes/E0433.stderr
+++ b/tests/ui/error-codes/E0433.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared type `NonExistingMap`
 LL |     let map = NonExistingMap::new();
    |               ^^^^^^^^^^^^^^ use of undeclared type `NonExistingMap`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/error-codes/E0434.stderr b/tests/ui/error-codes/E0434.stderr
index 14508ccbc9a..db9b087f5fd 100644
--- a/tests/ui/error-codes/E0434.stderr
+++ b/tests/ui/error-codes/E0434.stderr
@@ -6,6 +6,6 @@ LL |         y
    |
    = help: use the `|| { ... }` closure form instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0434`.
diff --git a/tests/ui/error-codes/E0435.stderr b/tests/ui/error-codes/E0435.stderr
index fc08fade91c..68d6ddba2a1 100644
--- a/tests/ui/error-codes/E0435.stderr
+++ b/tests/ui/error-codes/E0435.stderr
@@ -6,6 +6,6 @@ LL |     let foo: usize = 42;
 LL |     let _: [u8; foo];
    |                 ^^^ non-constant value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/error-codes/E0437.stderr b/tests/ui/error-codes/E0437.stderr
index 217b164036f..b011fa40e1e 100644
--- a/tests/ui/error-codes/E0437.stderr
+++ b/tests/ui/error-codes/E0437.stderr
@@ -4,6 +4,6 @@ error[E0437]: type `Bar` is not a member of trait `Foo`
 LL |     type Bar = bool;
    |     ^^^^^^^^^^^^^^^^ not a member of trait `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0437`.
diff --git a/tests/ui/error-codes/E0438.stderr b/tests/ui/error-codes/E0438.stderr
index 853f0c3c239..701c007afe3 100644
--- a/tests/ui/error-codes/E0438.stderr
+++ b/tests/ui/error-codes/E0438.stderr
@@ -4,6 +4,6 @@ error[E0438]: const `BAR` is not a member of trait `Bar`
 LL |     const BAR: bool = true;
    |     ^^^^^^^^^^^^^^^^^^^^^^^ not a member of trait `Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0438`.
diff --git a/tests/ui/error-codes/E0454.stderr b/tests/ui/error-codes/E0454.stderr
index b9a506fee83..e16982542cf 100644
--- a/tests/ui/error-codes/E0454.stderr
+++ b/tests/ui/error-codes/E0454.stderr
@@ -4,6 +4,6 @@ error[E0454]: link name must not be empty
 LL | #[link(name = "")] extern "C" {}
    |               ^^ empty link name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0454`.
diff --git a/tests/ui/error-codes/E0459.stderr b/tests/ui/error-codes/E0459.stderr
index 8f0dd25e030..21c1a50bf84 100644
--- a/tests/ui/error-codes/E0459.stderr
+++ b/tests/ui/error-codes/E0459.stderr
@@ -4,6 +4,6 @@ error[E0459]: `#[link]` attribute requires a `name = "string"` argument
 LL | #[link(kind = "dylib")] extern "C" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^ missing `name` argument
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0459`.
diff --git a/tests/ui/error-codes/E0462.stderr b/tests/ui/error-codes/E0462.stderr
index 43e27965ffc..18f20d79385 100644
--- a/tests/ui/error-codes/E0462.stderr
+++ b/tests/ui/error-codes/E0462.stderr
@@ -8,6 +8,6 @@ LL | extern crate found_staticlib;
            crate `found_staticlib`: $TEST_BUILD_DIR/error-codes/E0462/auxiliary/libfound_staticlib.somelib
    = help: please recompile that crate using --crate-type lib
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0462`.
diff --git a/tests/ui/error-codes/E0464.stderr b/tests/ui/error-codes/E0464.stderr
index 574270f94a6..edb0b1cf41e 100644
--- a/tests/ui/error-codes/E0464.stderr
+++ b/tests/ui/error-codes/E0464.stderr
@@ -8,6 +8,6 @@ LL | extern crate crateresolve1;
    = note: candidate #2: $TEST_BUILD_DIR/error-codes/E0464/auxiliary/libcrateresolve1-2.somelib
    = note: candidate #3: $TEST_BUILD_DIR/error-codes/E0464/auxiliary/libcrateresolve1-3.somelib
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0464`.
diff --git a/tests/ui/error-codes/E0478.stderr b/tests/ui/error-codes/E0478.stderr
index ec650085a2b..6ecde0e14e5 100644
--- a/tests/ui/error-codes/E0478.stderr
+++ b/tests/ui/error-codes/E0478.stderr
@@ -15,6 +15,6 @@ note: but lifetime parameter must outlive the lifetime `'kiss` as defined here
 LL | struct Prince<'kiss, 'SnowWhite> {
    |               ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0478`.
diff --git a/tests/ui/error-codes/E0496.stderr b/tests/ui/error-codes/E0496.stderr
index 80ca2b1fbdb..2d60aee77f8 100644
--- a/tests/ui/error-codes/E0496.stderr
+++ b/tests/ui/error-codes/E0496.stderr
@@ -6,6 +6,6 @@ LL | impl<'a> Foo<'a> {
 LL |     fn f<'a>(x: &'a i32) {
    |          ^^ lifetime `'a` already in scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0496`.
diff --git a/tests/ui/error-codes/E0499.stderr b/tests/ui/error-codes/E0499.stderr
index d56baf72272..03f2bad6cb5 100644
--- a/tests/ui/error-codes/E0499.stderr
+++ b/tests/ui/error-codes/E0499.stderr
@@ -9,6 +9,6 @@ LL |     a.use_mut();
 LL |     x.use_mut();
    |     - first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/error-codes/E0502.stderr b/tests/ui/error-codes/E0502.stderr
index cade6d71852..88d914c0e77 100644
--- a/tests/ui/error-codes/E0502.stderr
+++ b/tests/ui/error-codes/E0502.stderr
@@ -8,6 +8,6 @@ LL |     bar(a);
 LL |     y.use_ref();
    |     - immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/error-codes/E0503.stderr b/tests/ui/error-codes/E0503.stderr
index 275abb23f53..f1469cdc59b 100644
--- a/tests/ui/error-codes/E0503.stderr
+++ b/tests/ui/error-codes/E0503.stderr
@@ -8,6 +8,6 @@ LL |     let _sum = value + 1;
 LL |     _borrow.use_mut();
    |     ------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/error-codes/E0504.stderr b/tests/ui/error-codes/E0504.stderr
index 20e16a53810..c8a48961cb3 100644
--- a/tests/ui/error-codes/E0504.stderr
+++ b/tests/ui/error-codes/E0504.stderr
@@ -14,6 +14,6 @@ LL |         println!("child function: {}", fancy_num.num);
 LL |     println!("main function: {}", fancy_ref.num);
    |                                   ------------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/error-codes/E0505.stderr b/tests/ui/error-codes/E0505.stderr
index 1a85e031705..250680d2c1c 100644
--- a/tests/ui/error-codes/E0505.stderr
+++ b/tests/ui/error-codes/E0505.stderr
@@ -11,6 +11,6 @@ LL |         eat(x);
 LL |         _ref_to_val.use_ref();
    |         ----------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/error-codes/E0506.stderr b/tests/ui/error-codes/E0506.stderr
index 17ad7c611f8..2cc2885f775 100644
--- a/tests/ui/error-codes/E0506.stderr
+++ b/tests/ui/error-codes/E0506.stderr
@@ -9,6 +9,6 @@ LL |
 LL |     println!("Num: {}, Ref: {}", fancy_num.num, fancy_ref.num);
    |                                                 ------------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/error-codes/E0507.stderr b/tests/ui/error-codes/E0507.stderr
index 08993951622..767fedfccbf 100644
--- a/tests/ui/error-codes/E0507.stderr
+++ b/tests/ui/error-codes/E0507.stderr
@@ -12,6 +12,6 @@ note: `TheDarkKnight::nothing_is_true` takes ownership of the receiver `self`, w
 LL |     fn nothing_is_true(self) {}
    |                        ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/error-codes/E0508-fail.stderr b/tests/ui/error-codes/E0508-fail.stderr
index 208ba30729f..1153b1d09c7 100644
--- a/tests/ui/error-codes/E0508-fail.stderr
+++ b/tests/ui/error-codes/E0508-fail.stderr
@@ -12,6 +12,6 @@ help: consider borrowing here
 LL |     let _value = &array[0];
    |                  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/error-codes/E0508.stderr b/tests/ui/error-codes/E0508.stderr
index df2d3b0d311..4c864e24144 100644
--- a/tests/ui/error-codes/E0508.stderr
+++ b/tests/ui/error-codes/E0508.stderr
@@ -12,6 +12,6 @@ help: consider borrowing here
 LL |     let _value = &array[0];
    |                  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/error-codes/E0509.stderr b/tests/ui/error-codes/E0509.stderr
index c00d9142e75..59843a5491a 100644
--- a/tests/ui/error-codes/E0509.stderr
+++ b/tests/ui/error-codes/E0509.stderr
@@ -12,6 +12,6 @@ help: consider borrowing here
 LL |     let fancy_field = &drop_struct.fancy;
    |                       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0509`.
diff --git a/tests/ui/error-codes/E0511.stderr b/tests/ui/error-codes/E0511.stderr
index d797b10d5a6..59eb19d2ee5 100644
--- a/tests/ui/error-codes/E0511.stderr
+++ b/tests/ui/error-codes/E0511.stderr
@@ -4,6 +4,6 @@ error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD in
 LL |     unsafe { simd_add(0, 1); }
    |              ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0511`.
diff --git a/tests/ui/error-codes/E0512.stderr b/tests/ui/error-codes/E0512.stderr
index 3fecce542ce..eb8ce8b17a4 100644
--- a/tests/ui/error-codes/E0512.stderr
+++ b/tests/ui/error-codes/E0512.stderr
@@ -7,6 +7,6 @@ LL |     unsafe { takes_u8(::std::mem::transmute(0u16)); }
    = note: source type: `u16` (16 bits)
    = note: target type: `u8` (8 bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/error-codes/E0516.stderr b/tests/ui/error-codes/E0516.stderr
index 5243b7caf22..62e70a4668d 100644
--- a/tests/ui/error-codes/E0516.stderr
+++ b/tests/ui/error-codes/E0516.stderr
@@ -9,6 +9,6 @@ help: consider replacing `typeof(...)` with an actual type
 LL |     let x: i32 = 92;
    |            ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0516`.
diff --git a/tests/ui/error-codes/E0519.stderr b/tests/ui/error-codes/E0519.stderr
index e24fc4aaa70..4fbd268134f 100644
--- a/tests/ui/error-codes/E0519.stderr
+++ b/tests/ui/error-codes/E0519.stderr
@@ -4,6 +4,6 @@ error[E0519]: the current crate is indistinguishable from one of its dependencie
 LL | extern crate crateresolve1;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0519`.
diff --git a/tests/ui/error-codes/E0520.stderr b/tests/ui/error-codes/E0520.stderr
index 06658a49b83..83319203023 100644
--- a/tests/ui/error-codes/E0520.stderr
+++ b/tests/ui/error-codes/E0520.stderr
@@ -19,6 +19,6 @@ LL |     default fn fly(&self) {}
    |
    = note: to specialize, `fly` in the parent `impl` must be marked `default`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/error-codes/E0522.stderr b/tests/ui/error-codes/E0522.stderr
index 0a8a41598da..66359cbacc8 100644
--- a/tests/ui/error-codes/E0522.stderr
+++ b/tests/ui/error-codes/E0522.stderr
@@ -4,6 +4,6 @@ error[E0522]: definition of an unknown language item: `cookie`
 LL | #[lang = "cookie"]
    | ^^^^^^^^^^^^^^^^^^ definition of unknown language item `cookie`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0522`.
diff --git a/tests/ui/error-codes/E0523.stderr b/tests/ui/error-codes/E0523.stderr
index 8e3eb2159c2..c6e65b55e2b 100644
--- a/tests/ui/error-codes/E0523.stderr
+++ b/tests/ui/error-codes/E0523.stderr
@@ -8,6 +8,6 @@ LL | extern crate crateresolve1;
    = note: candidate #2: $TEST_BUILD_DIR/error-codes/E0523/auxiliary/libcrateresolve1-2.somelib
    = note: candidate #3: $TEST_BUILD_DIR/error-codes/E0523/auxiliary/libcrateresolve1-3.somelib
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0464`.
diff --git a/tests/ui/error-codes/E0527.stderr b/tests/ui/error-codes/E0527.stderr
index a2e6288b21b..80d8412a520 100644
--- a/tests/ui/error-codes/E0527.stderr
+++ b/tests/ui/error-codes/E0527.stderr
@@ -4,6 +4,6 @@ error[E0527]: pattern requires 2 elements but array has 4
 LL |         &[a, b] => {
    |          ^^^^^^ expected 4 elements
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0527`.
diff --git a/tests/ui/error-codes/E0528.stderr b/tests/ui/error-codes/E0528.stderr
index 21615f954c3..94c83d36e22 100644
--- a/tests/ui/error-codes/E0528.stderr
+++ b/tests/ui/error-codes/E0528.stderr
@@ -4,6 +4,6 @@ error[E0528]: pattern requires at least 3 elements but array has 2
 LL |         &[a, b, c, rest @ ..] => {
    |          ^^^^^^^^^^^^^^^^^^^^ pattern cannot match array of 2 elements
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0528`.
diff --git a/tests/ui/error-codes/E0529.stderr b/tests/ui/error-codes/E0529.stderr
index 96b22bb2263..b3e25a96525 100644
--- a/tests/ui/error-codes/E0529.stderr
+++ b/tests/ui/error-codes/E0529.stderr
@@ -4,6 +4,6 @@ error[E0529]: expected an array or slice, found `f32`
 LL |         [a, b] => {
    |         ^^^^^^ pattern cannot match with input type `f32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0529`.
diff --git a/tests/ui/error-codes/E0530.stderr b/tests/ui/error-codes/E0530.stderr
index c312144132d..125b60bc914 100644
--- a/tests/ui/error-codes/E0530.stderr
+++ b/tests/ui/error-codes/E0530.stderr
@@ -7,6 +7,6 @@ LL |     static TEST: i32 = 0;
 LL |         TEST => {}
    |         ^^^^ cannot be named the same as a static
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0530`.
diff --git a/tests/ui/error-codes/E0532.stderr b/tests/ui/error-codes/E0532.stderr
index eeccadccc63..0cd276a3cc7 100644
--- a/tests/ui/error-codes/E0532.stderr
+++ b/tests/ui/error-codes/E0532.stderr
@@ -4,6 +4,6 @@ error[E0532]: expected tuple struct or tuple variant, found constant `StructCons
 LL |         StructConst1(_) => { },
    |         ^^^^^^^^^^^^ not a tuple struct or tuple variant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/error-codes/E0534.stderr b/tests/ui/error-codes/E0534.stderr
index 23f9cd7ce2d..6983de7ab69 100644
--- a/tests/ui/error-codes/E0534.stderr
+++ b/tests/ui/error-codes/E0534.stderr
@@ -4,6 +4,6 @@ error[E0534]: expected one argument
 LL | #[inline()]
    | ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0534`.
diff --git a/tests/ui/error-codes/E0559.stderr b/tests/ui/error-codes/E0559.stderr
index 63ee1cd7820..59317780f41 100644
--- a/tests/ui/error-codes/E0559.stderr
+++ b/tests/ui/error-codes/E0559.stderr
@@ -6,6 +6,6 @@ LL |     let s = Field::Fool { joke: 0 };
    |
    = note: available fields are: `x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0559`.
diff --git a/tests/ui/error-codes/E0560.stderr b/tests/ui/error-codes/E0560.stderr
index bb5ce478ae1..934bc41cce2 100644
--- a/tests/ui/error-codes/E0560.stderr
+++ b/tests/ui/error-codes/E0560.stderr
@@ -6,6 +6,6 @@ LL |     let s = Simba { mother: 1, father: 0 };
    |
    = note: all struct fields are already assigned
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/error-codes/E0565-1.stderr b/tests/ui/error-codes/E0565-1.stderr
index 1283a9c5ef6..806eed2a632 100644
--- a/tests/ui/error-codes/E0565-1.stderr
+++ b/tests/ui/error-codes/E0565-1.stderr
@@ -4,6 +4,6 @@ error[E0565]: item in `deprecated` must be a key/value pair
 LL | #[deprecated("since")]
    |              ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0565`.
diff --git a/tests/ui/error-codes/E0565-2.stderr b/tests/ui/error-codes/E0565-2.stderr
index 097871bd319..42199351c3d 100644
--- a/tests/ui/error-codes/E0565-2.stderr
+++ b/tests/ui/error-codes/E0565-2.stderr
@@ -6,6 +6,6 @@ LL | #[deprecated(since = b"1.29", note = "hi")]
    |                      |
    |                      help: consider removing the prefix
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0565`.
diff --git a/tests/ui/error-codes/E0565.stderr b/tests/ui/error-codes/E0565.stderr
index 6ed90c0ae4f..68f4a37dcff 100644
--- a/tests/ui/error-codes/E0565.stderr
+++ b/tests/ui/error-codes/E0565.stderr
@@ -4,6 +4,6 @@ error[E0565]: meta item in `repr` must be an identifier
 LL | #[repr("C")]
    |        ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0565`.
diff --git a/tests/ui/error-codes/E0572.stderr b/tests/ui/error-codes/E0572.stderr
index 36619f8dee4..e0f59ec8468 100644
--- a/tests/ui/error-codes/E0572.stderr
+++ b/tests/ui/error-codes/E0572.stderr
@@ -4,6 +4,6 @@ error[E0572]: return statement outside of function body
 LL | const FOO: u32 = return 0;
    |                  ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/error-codes/E0583.stderr b/tests/ui/error-codes/E0583.stderr
index 6707f2864f2..cad61dde475 100644
--- a/tests/ui/error-codes/E0583.stderr
+++ b/tests/ui/error-codes/E0583.stderr
@@ -7,6 +7,6 @@ LL | mod module_that_doesnt_exist;
    = help: to create the module `module_that_doesnt_exist`, create file "$DIR/module_that_doesnt_exist.rs" or "$DIR/module_that_doesnt_exist/mod.rs"
    = note: if there is a `mod module_that_doesnt_exist` elsewhere in the crate already, import it with `use crate::...` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0583`.
diff --git a/tests/ui/error-codes/E0585.stderr b/tests/ui/error-codes/E0585.stderr
index 53c82fb416b..f0464cc0b03 100644
--- a/tests/ui/error-codes/E0585.stderr
+++ b/tests/ui/error-codes/E0585.stderr
@@ -6,6 +6,6 @@ LL |     /// Hello! I'm useless...
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/error-codes/E0586.stderr b/tests/ui/error-codes/E0586.stderr
index 0bbf9a60803..f562e358cba 100644
--- a/tests/ui/error-codes/E0586.stderr
+++ b/tests/ui/error-codes/E0586.stderr
@@ -6,6 +6,6 @@ LL |     let x = &tmp[1..=];
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0586`.
diff --git a/tests/ui/error-codes/E0594.stderr b/tests/ui/error-codes/E0594.stderr
index f4d96f4e45a..e010cda83ff 100644
--- a/tests/ui/error-codes/E0594.stderr
+++ b/tests/ui/error-codes/E0594.stderr
@@ -4,6 +4,6 @@ error[E0594]: cannot assign to immutable static item `NUM`
 LL |     NUM = 20;
    |     ^^^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/error-codes/E0596.stderr b/tests/ui/error-codes/E0596.stderr
index 3f9aebcc8ae..9f1092d88cf 100644
--- a/tests/ui/error-codes/E0596.stderr
+++ b/tests/ui/error-codes/E0596.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut x = 1;
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/error-codes/E0597.stderr b/tests/ui/error-codes/E0597.stderr
index 82e3481b65a..d3206112bd0 100644
--- a/tests/ui/error-codes/E0597.stderr
+++ b/tests/ui/error-codes/E0597.stderr
@@ -14,6 +14,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/error-codes/E0599.stderr b/tests/ui/error-codes/E0599.stderr
index a1fb58f483f..5c1c71d39f7 100644
--- a/tests/ui/error-codes/E0599.stderr
+++ b/tests/ui/error-codes/E0599.stderr
@@ -7,6 +7,6 @@ LL | struct Foo;
 LL |     || if let Foo::NotEvenReal() = Foo {};
    |                    ^^^^^^^^^^^ associated item not found in `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/error-codes/E0600.stderr b/tests/ui/error-codes/E0600.stderr
index 95ac4510ca8..a76f2354da6 100644
--- a/tests/ui/error-codes/E0600.stderr
+++ b/tests/ui/error-codes/E0600.stderr
@@ -4,6 +4,6 @@ error[E0600]: cannot apply unary operator `!` to type `&'static str`
 LL |     !"a";
    |     ^^^^ cannot apply unary operator `!`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/error-codes/E0601.stderr b/tests/ui/error-codes/E0601.stderr
index a687f575615..41a4a8f7dbb 100644
--- a/tests/ui/error-codes/E0601.stderr
+++ b/tests/ui/error-codes/E0601.stderr
@@ -4,6 +4,6 @@ error[E0601]: `main` function not found in crate `E0601`
 LL |
    |                                     ^ consider adding a `main` function to `$DIR/E0601.rs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/error-codes/E0603.stderr b/tests/ui/error-codes/E0603.stderr
index ee902584f56..1ac1bbd89a7 100644
--- a/tests/ui/error-codes/E0603.stderr
+++ b/tests/ui/error-codes/E0603.stderr
@@ -10,6 +10,6 @@ note: the constant `PRIVATE` is defined here
 LL |     const PRIVATE: u32 = 0x_a_bad_1dea_u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/error-codes/E0604.stderr b/tests/ui/error-codes/E0604.stderr
index 68da03928b7..e91f74d6b3f 100644
--- a/tests/ui/error-codes/E0604.stderr
+++ b/tests/ui/error-codes/E0604.stderr
@@ -7,6 +7,6 @@ LL |     1u32 as char;
    |     invalid cast
    |     help: try `char::from_u32` instead: `char::from_u32(1u32)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0604`.
diff --git a/tests/ui/error-codes/E0607.stderr b/tests/ui/error-codes/E0607.stderr
index a0fe02c1c4d..835ababf449 100644
--- a/tests/ui/error-codes/E0607.stderr
+++ b/tests/ui/error-codes/E0607.stderr
@@ -4,6 +4,6 @@ error[E0607]: cannot cast thin pointer `*const u8` to fat pointer `*const [u8]`
 LL |     v as *const [u8];
    |     ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0607`.
diff --git a/tests/ui/error-codes/E0608.stderr b/tests/ui/error-codes/E0608.stderr
index f23f9977ba0..da7be147819 100644
--- a/tests/ui/error-codes/E0608.stderr
+++ b/tests/ui/error-codes/E0608.stderr
@@ -4,6 +4,6 @@ error[E0608]: cannot index into a value of type `u8`
 LL |     0u8[2];
    |        ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0608`.
diff --git a/tests/ui/error-codes/E0609-private-method.stderr b/tests/ui/error-codes/E0609-private-method.stderr
index d2a11e90627..c889765be54 100644
--- a/tests/ui/error-codes/E0609-private-method.stderr
+++ b/tests/ui/error-codes/E0609-private-method.stderr
@@ -4,6 +4,6 @@ error[E0609]: no field `method` on type `Foo`
 LL |     f.method;
    |       ^^^^^^ unknown field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/error-codes/E0610.stderr b/tests/ui/error-codes/E0610.stderr
index a2966eea44c..4263368ff42 100644
--- a/tests/ui/error-codes/E0610.stderr
+++ b/tests/ui/error-codes/E0610.stderr
@@ -4,6 +4,6 @@ error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields
 LL |     let _ = x.foo;
    |               ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0610`.
diff --git a/tests/ui/error-codes/E0614.stderr b/tests/ui/error-codes/E0614.stderr
index 598117c2b60..ae7c2ce9a13 100644
--- a/tests/ui/error-codes/E0614.stderr
+++ b/tests/ui/error-codes/E0614.stderr
@@ -4,6 +4,6 @@ error[E0614]: type `u32` cannot be dereferenced
 LL |     *y;
    |     ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0614`.
diff --git a/tests/ui/error-codes/E0615.stderr b/tests/ui/error-codes/E0615.stderr
index c12e1a3a643..13446a475a0 100644
--- a/tests/ui/error-codes/E0615.stderr
+++ b/tests/ui/error-codes/E0615.stderr
@@ -9,6 +9,6 @@ help: use parentheses to call the method
 LL |     f.method();
    |             ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/error-codes/E0616.stderr b/tests/ui/error-codes/E0616.stderr
index da349ed2fde..73eb64ab468 100644
--- a/tests/ui/error-codes/E0616.stderr
+++ b/tests/ui/error-codes/E0616.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `x` of struct `Foo` is private
 LL |     f.x;
    |       ^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/error-codes/E0620.stderr b/tests/ui/error-codes/E0620.stderr
index 65152b2b74d..5bc8903624c 100644
--- a/tests/ui/error-codes/E0620.stderr
+++ b/tests/ui/error-codes/E0620.stderr
@@ -10,6 +10,6 @@ help: consider using an implicit coercion to `&[usize]` instead
 LL |     let _foo = &[1_usize, 2] as [usize];
    |                ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0620`.
diff --git a/tests/ui/error-codes/E0621-does-not-trigger-for-closures.stderr b/tests/ui/error-codes/E0621-does-not-trigger-for-closures.stderr
index b9edeb8346b..2d96926a230 100644
--- a/tests/ui/error-codes/E0621-does-not-trigger-for-closures.stderr
+++ b/tests/ui/error-codes/E0621-does-not-trigger-for-closures.stderr
@@ -7,5 +7,5 @@ LL |     invoke(&x, |a, b| if a > b { a } else { b });
    |                    |return type of closure is &'2 i32
    |                    has type `&'1 i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0622.stderr b/tests/ui/error-codes/E0622.stderr
index 8466dfe3848..c59776b211f 100644
--- a/tests/ui/error-codes/E0622.stderr
+++ b/tests/ui/error-codes/E0622.stderr
@@ -4,6 +4,6 @@ error[E0622]: intrinsic must be a function
 LL |     pub static breakpoint : unsafe extern "rust-intrinsic" fn();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected a function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0622`.
diff --git a/tests/ui/error-codes/E0624.stderr b/tests/ui/error-codes/E0624.stderr
index 23a8ea8a8c9..b2bc2c92d36 100644
--- a/tests/ui/error-codes/E0624.stderr
+++ b/tests/ui/error-codes/E0624.stderr
@@ -7,6 +7,6 @@ LL |         fn method(&self) {}
 LL |     foo.method();
    |         ^^^^^^ private method
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/error-codes/E0646.stderr b/tests/ui/error-codes/E0646.stderr
index 069401b3f18..7f8d7ae7022 100644
--- a/tests/ui/error-codes/E0646.stderr
+++ b/tests/ui/error-codes/E0646.stderr
@@ -4,6 +4,6 @@ error[E0646]: `main` function is not allowed to have a `where` clause
 LL | fn main() where (): Copy {}
    |           ^^^^^^^^^^^^^^ `main` cannot have a `where` clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0646`.
diff --git a/tests/ui/error-codes/E0647.stderr b/tests/ui/error-codes/E0647.stderr
index 9d1ab967127..4b444e5a397 100644
--- a/tests/ui/error-codes/E0647.stderr
+++ b/tests/ui/error-codes/E0647.stderr
@@ -4,6 +4,6 @@ error[E0647]: `#[start]` function is not allowed to have a `where` clause
 LL | fn start(_: isize, _: *const *const u8) -> isize where (): Copy {
    |                                                  ^^^^^^^^^^^^^^ `#[start]` function cannot have a `where` clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0647`.
diff --git a/tests/ui/error-codes/E0648.stderr b/tests/ui/error-codes/E0648.stderr
index 1a65825c7b6..e995e531395 100644
--- a/tests/ui/error-codes/E0648.stderr
+++ b/tests/ui/error-codes/E0648.stderr
@@ -4,6 +4,6 @@ error[E0648]: `export_name` may not contain null characters
 LL | #[export_name="\0foo"]
    | ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0648`.
diff --git a/tests/ui/error-codes/E0658.stderr b/tests/ui/error-codes/E0658.stderr
index 8d423484528..686394b6d22 100644
--- a/tests/ui/error-codes/E0658.stderr
+++ b/tests/ui/error-codes/E0658.stderr
@@ -7,6 +7,6 @@ LL | enum Foo {
    = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
    = help: add `#![feature(repr128)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/error-codes/E0659.stderr b/tests/ui/error-codes/E0659.stderr
index b0c73c636c6..dbb72bb6759 100644
--- a/tests/ui/error-codes/E0659.stderr
+++ b/tests/ui/error-codes/E0659.stderr
@@ -18,6 +18,6 @@ LL |     pub use earth::*;
    |             ^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/error-codes/E0718.stderr b/tests/ui/error-codes/E0718.stderr
index 30378dd1674..9a3db136d23 100644
--- a/tests/ui/error-codes/E0718.stderr
+++ b/tests/ui/error-codes/E0718.stderr
@@ -4,6 +4,6 @@ error[E0718]: `owned_box` language item must be applied to a struct
 LL | #[lang = "owned_box"]
    | ^^^^^^^^^^^^^^^^^^^^^ attribute should be applied to a struct, not a static item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0718`.
diff --git a/tests/ui/error-codes/E0730.stderr b/tests/ui/error-codes/E0730.stderr
index 067e8c57cd6..5e996ac3555 100644
--- a/tests/ui/error-codes/E0730.stderr
+++ b/tests/ui/error-codes/E0730.stderr
@@ -4,6 +4,6 @@ error[E0730]: cannot pattern-match on an array without a fixed length
 LL |         [1, 2, ..] => true,
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0730`.
diff --git a/tests/ui/error-codes/E0771.stderr b/tests/ui/error-codes/E0771.stderr
index 9450c61c27b..e1384effe37 100644
--- a/tests/ui/error-codes/E0771.stderr
+++ b/tests/ui/error-codes/E0771.stderr
@@ -15,6 +15,6 @@ LL | #![feature(adt_const_params)]
    = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
    = note: `#[warn(incomplete_features)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/error-codes/E0778.stderr b/tests/ui/error-codes/E0778.stderr
index 42647e5c6a1..7eb24c493bf 100644
--- a/tests/ui/error-codes/E0778.stderr
+++ b/tests/ui/error-codes/E0778.stderr
@@ -4,6 +4,6 @@ error[E0778]: `#[instruction_set]` requires an argument
 LL | #[instruction_set()]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0778`.
diff --git a/tests/ui/error-codes/E0779.stderr b/tests/ui/error-codes/E0779.stderr
index 7c6a119a096..a01aa98b914 100644
--- a/tests/ui/error-codes/E0779.stderr
+++ b/tests/ui/error-codes/E0779.stderr
@@ -4,6 +4,6 @@ error[E0779]: invalid instruction set specified
 LL | #[instruction_set(arm::magic)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0779`.
diff --git a/tests/ui/error-codes/e0119/complex-impl.stderr b/tests/ui/error-codes/e0119/complex-impl.stderr
index 654073eec26..c0519c60e42 100644
--- a/tests/ui/error-codes/e0119/complex-impl.stderr
+++ b/tests/ui/error-codes/e0119/complex-impl.stderr
@@ -9,6 +9,6 @@ LL | impl<R> External for (Q, R) {}
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/error-codes/e0119/issue-23563.stderr b/tests/ui/error-codes/e0119/issue-23563.stderr
index 1b2d64282e1..86737742f74 100644
--- a/tests/ui/error-codes/e0119/issue-23563.stderr
+++ b/tests/ui/error-codes/e0119/issue-23563.stderr
@@ -8,6 +8,6 @@ LL | impl<'a, T> LolFrom<&'a [T]> for LocalType<T> {
            - impl<T, U> LolFrom<T> for U
              where T: LolInto<U>;
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/error-codes/e0119/issue-27403.stderr b/tests/ui/error-codes/e0119/issue-27403.stderr
index 9b3345c23bb..b0918a3d649 100644
--- a/tests/ui/error-codes/e0119/issue-27403.stderr
+++ b/tests/ui/error-codes/e0119/issue-27403.stderr
@@ -8,6 +8,6 @@ LL | impl<S> Into<S> for GenX<S> {
            - impl<T, U> Into<U> for T
              where U: From<T>;
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/error-codes/e0119/issue-28981.stderr b/tests/ui/error-codes/e0119/issue-28981.stderr
index 97b570bc7ac..be3e4aea51a 100644
--- a/tests/ui/error-codes/e0119/issue-28981.stderr
+++ b/tests/ui/error-codes/e0119/issue-28981.stderr
@@ -7,6 +7,6 @@ LL | impl<Foo> Deref for Foo { }
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/error-codes/e0119/so-37347311.stderr b/tests/ui/error-codes/e0119/so-37347311.stderr
index 99367e80841..869b11b1909 100644
--- a/tests/ui/error-codes/e0119/so-37347311.stderr
+++ b/tests/ui/error-codes/e0119/so-37347311.stderr
@@ -7,6 +7,6 @@ LL | impl<S: Storage> From<S::Error> for MyError<S> {
    = note: conflicting implementation in crate `core`:
            - impl<T> From<T> for T;
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/error-codes/ex-E0611.stderr b/tests/ui/error-codes/ex-E0611.stderr
index 1da7b33be9d..fb61eba1509 100644
--- a/tests/ui/error-codes/ex-E0611.stderr
+++ b/tests/ui/error-codes/ex-E0611.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `0` of struct `Foo` is private
 LL |    y.0;
    |      ^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/error-codes/ex-E0612.stderr b/tests/ui/error-codes/ex-E0612.stderr
index 4dd9848cf07..23c1697b9b2 100644
--- a/tests/ui/error-codes/ex-E0612.stderr
+++ b/tests/ui/error-codes/ex-E0612.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |    y.0;
    |      ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/error-should-say-copy-not-pod.stderr b/tests/ui/error-should-say-copy-not-pod.stderr
index 637eb27db01..658584e2ff4 100644
--- a/tests/ui/error-should-say-copy-not-pod.stderr
+++ b/tests/ui/error-should-say-copy-not-pod.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `check_bound`
 LL | fn check_bound<T:Copy>(_: T) {}
    |                  ^^^^ required by this bound in `check_bound`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/errors/issue-104621-extern-not-file.stderr b/tests/ui/errors/issue-104621-extern-not-file.stderr
index 5aaf9741360..61496e5b57b 100644
--- a/tests/ui/errors/issue-104621-extern-not-file.stderr
+++ b/tests/ui/errors/issue-104621-extern-not-file.stderr
@@ -4,5 +4,5 @@ error: extern location for foo is not a file: .
 LL | extern crate foo;
    | ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr b/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr
index 51e3b776cb2..7aa66be0d09 100644
--- a/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr
+++ b/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr
@@ -9,6 +9,6 @@ LL |     let _ = remapped_dep::SomeStruct; // ~ERROR E0423
 LL | pub struct SomeStruct {} // This line should be show as part of the error.
    | --------------------- `remapped_dep::SomeStruct` defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr b/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr
index 51e3b776cb2..7aa66be0d09 100644
--- a/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr
+++ b/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr
@@ -9,6 +9,6 @@ LL |     let _ = remapped_dep::SomeStruct; // ~ERROR E0423
 LL | pub struct SomeStruct {} // This line should be show as part of the error.
    | --------------------- `remapped_dep::SomeStruct` defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/errors/remap-path-prefix.normal.stderr b/tests/ui/errors/remap-path-prefix.normal.stderr
index 004f10b4e43..46d33d26052 100644
--- a/tests/ui/errors/remap-path-prefix.normal.stderr
+++ b/tests/ui/errors/remap-path-prefix.normal.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `ferris` in this scope
 LL |     ferris
    |     ^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/errors/remap-path-prefix.with-diagnostic-scope.stderr b/tests/ui/errors/remap-path-prefix.with-diagnostic-scope.stderr
index 004f10b4e43..46d33d26052 100644
--- a/tests/ui/errors/remap-path-prefix.with-diagnostic-scope.stderr
+++ b/tests/ui/errors/remap-path-prefix.with-diagnostic-scope.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `ferris` in this scope
 LL |     ferris
    |     ^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/errors/remap-path-prefix.without-diagnostic-scope.stderr b/tests/ui/errors/remap-path-prefix.without-diagnostic-scope.stderr
index 98fe328193c..0badea6e27b 100644
--- a/tests/ui/errors/remap-path-prefix.without-diagnostic-scope.stderr
+++ b/tests/ui/errors/remap-path-prefix.without-diagnostic-scope.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `ferris` in this scope
 LL |     ferris
    |     ^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/explicit-tail-calls/become-outside.array.stderr b/tests/ui/explicit-tail-calls/become-outside.array.stderr
index 839c20509fe..81ed683737c 100644
--- a/tests/ui/explicit-tail-calls/become-outside.array.stderr
+++ b/tests/ui/explicit-tail-calls/become-outside.array.stderr
@@ -4,6 +4,6 @@ error[E0572]: become statement outside of function body
 LL | struct Bad([(); become f()]);
    |                 ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/explicit-tail-calls/become-outside.constant.stderr b/tests/ui/explicit-tail-calls/become-outside.constant.stderr
index 9b67f08af3a..07747e2cc9c 100644
--- a/tests/ui/explicit-tail-calls/become-outside.constant.stderr
+++ b/tests/ui/explicit-tail-calls/become-outside.constant.stderr
@@ -4,6 +4,6 @@ error[E0572]: become statement outside of function body
 LL |     become f();
    |     ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/explicit/explicit-call-to-dtor.stderr b/tests/ui/explicit/explicit-call-to-dtor.stderr
index f2e0b73b6c5..6f40f3998a9 100644
--- a/tests/ui/explicit/explicit-call-to-dtor.stderr
+++ b/tests/ui/explicit/explicit-call-to-dtor.stderr
@@ -9,6 +9,6 @@ help: consider using `drop` function
 LL |     drop(x);
    |     +++++ ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0040`.
diff --git a/tests/ui/explicit/explicit-call-to-supertrait-dtor.stderr b/tests/ui/explicit/explicit-call-to-supertrait-dtor.stderr
index 5fa42fcf191..d2d69ce6daf 100644
--- a/tests/ui/explicit/explicit-call-to-supertrait-dtor.stderr
+++ b/tests/ui/explicit/explicit-call-to-supertrait-dtor.stderr
@@ -9,6 +9,6 @@ help: consider using `drop` function
 LL |         drop(self);
    |         +++++    ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0040`.
diff --git a/tests/ui/expr/if/attrs/bad-cfg.stderr b/tests/ui/expr/if/attrs/bad-cfg.stderr
index 8a2890886a1..ca0eced267d 100644
--- a/tests/ui/expr/if/attrs/bad-cfg.stderr
+++ b/tests/ui/expr/if/attrs/bad-cfg.stderr
@@ -4,5 +4,5 @@ error: removing an expression is not supported in this position
 LL |     let _ = #[cfg(FALSE)] if true {};
    |             ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/expr/if/attrs/stmt-expr-gated.stderr b/tests/ui/expr/if/attrs/stmt-expr-gated.stderr
index 47dac39a9ae..afc26757c46 100644
--- a/tests/ui/expr/if/attrs/stmt-expr-gated.stderr
+++ b/tests/ui/expr/if/attrs/stmt-expr-gated.stderr
@@ -7,6 +7,6 @@ LL |     let _ = #[deny(warnings)] if true {
    = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
    = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/expr/if/if-branch-types.stderr b/tests/ui/expr/if/if-branch-types.stderr
index d2bba88211e..0e86a24f31b 100644
--- a/tests/ui/expr/if/if-branch-types.stderr
+++ b/tests/ui/expr/if/if-branch-types.stderr
@@ -11,6 +11,6 @@ help: change the type of the numeric literal from `u32` to `i32`
 LL |     let x = if true { 10i32 } else { 10i32 };
    |                                        ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/expr/if/if-let-arm-types.stderr b/tests/ui/expr/if/if-let-arm-types.stderr
index b40a0f479d3..285f5c4a6f2 100644
--- a/tests/ui/expr/if/if-let-arm-types.stderr
+++ b/tests/ui/expr/if/if-let-arm-types.stderr
@@ -12,6 +12,6 @@ LL | |         1
 LL | |     };
    | |_____- `if` and `else` have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/expr/if/if-typeck.stderr b/tests/ui/expr/if/if-typeck.stderr
index 74ed0ed0ae6..1be43a20105 100644
--- a/tests/ui/expr/if/if-typeck.stderr
+++ b/tests/ui/expr/if/if-typeck.stderr
@@ -7,6 +7,6 @@ LL |     if f { }
    = note: expected type `bool`
            found fn item `fn() {f}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/expr/if/if-without-block.stderr b/tests/ui/expr/if/if-without-block.stderr
index 2d1ee04ce09..98bde827a72 100644
--- a/tests/ui/expr/if/if-without-block.stderr
+++ b/tests/ui/expr/if/if-without-block.stderr
@@ -10,5 +10,5 @@ help: this binary operation is possibly unfinished
 LL |     if 5 == {
    |        ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/expr/if/if-without-else-result.stderr b/tests/ui/expr/if/if-without-else-result.stderr
index 317faf7c619..4eaa0393496 100644
--- a/tests/ui/expr/if/if-without-else-result.stderr
+++ b/tests/ui/expr/if/if-without-else-result.stderr
@@ -10,6 +10,6 @@ LL |     let a = if true { true };
    = note: `if` expressions without `else` evaluate to `()`
    = help: consider adding an `else` block that evaluates to the expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0317`.
diff --git a/tests/ui/expr/if/issue-4201.stderr b/tests/ui/expr/if/issue-4201.stderr
index 612fe77642c..c761d0b8553 100644
--- a/tests/ui/expr/if/issue-4201.stderr
+++ b/tests/ui/expr/if/issue-4201.stderr
@@ -13,6 +13,6 @@ LL | |     };
    = note: `if` expressions without `else` evaluate to `()`
    = help: consider adding an `else` block that evaluates to the expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0317`.
diff --git a/tests/ui/expr/malformed_closure/block_instead_of_closure_in_arg.stderr b/tests/ui/expr/malformed_closure/block_instead_of_closure_in_arg.stderr
index f70b3211743..1264d969342 100644
--- a/tests/ui/expr/malformed_closure/block_instead_of_closure_in_arg.stderr
+++ b/tests/ui/expr/malformed_closure/block_instead_of_closure_in_arg.stderr
@@ -22,6 +22,6 @@ help: you might have meant to create the closure instead of a block
 LL |     Some(true).filter(|_| {
    |                       +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/expr/malformed_closure/missing_block_in_let_binding.stderr b/tests/ui/expr/malformed_closure/missing_block_in_let_binding.stderr
index d4640fba96c..8af7030172c 100644
--- a/tests/ui/expr/malformed_closure/missing_block_in_let_binding.stderr
+++ b/tests/ui/expr/malformed_closure/missing_block_in_let_binding.stderr
@@ -12,5 +12,5 @@ help: you might have meant to open the body of the closure
 LL |     let x = |x| {
    |                 +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/expr/malformed_closure/ruby_style_closure.stderr b/tests/ui/expr/malformed_closure/ruby_style_closure.stderr
index e8b34121b5f..b1607bbacc9 100644
--- a/tests/ui/expr/malformed_closure/ruby_style_closure.stderr
+++ b/tests/ui/expr/malformed_closure/ruby_style_closure.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `x` in this scope
 LL |         Some(x * 2)
    |              ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/expr/malformed_closure/ruby_style_closure_successful_parse.stderr b/tests/ui/expr/malformed_closure/ruby_style_closure_successful_parse.stderr
index e44ec5ca93c..a7ed9f5880b 100644
--- a/tests/ui/expr/malformed_closure/ruby_style_closure_successful_parse.stderr
+++ b/tests/ui/expr/malformed_closure/ruby_style_closure_successful_parse.stderr
@@ -20,6 +20,6 @@ LL -     let p = Some(45).and_then({|x|
 LL +     let p = Some(45).and_then(|x| {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/ext-nonexistent.stderr b/tests/ui/ext-nonexistent.stderr
index f3aa83fd508..8891e823e4a 100644
--- a/tests/ui/ext-nonexistent.stderr
+++ b/tests/ui/ext-nonexistent.stderr
@@ -4,5 +4,5 @@ error: cannot find macro `iamnotanextensionthatexists` in this scope
 LL | fn main() { iamnotanextensionthatexists!(""); }
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-arg-2-not-string-literal.stderr b/tests/ui/extenv/extenv-arg-2-not-string-literal.stderr
index 258e2b347fb..9db1c0be746 100644
--- a/tests/ui/extenv/extenv-arg-2-not-string-literal.stderr
+++ b/tests/ui/extenv/extenv-arg-2-not-string-literal.stderr
@@ -4,5 +4,5 @@ error: expected string literal
 LL | fn main() { env!("one", 10); }
    |                         ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-escaped-var.stderr b/tests/ui/extenv/extenv-escaped-var.stderr
index 25e218c63f3..ef5e654d054 100644
--- a/tests/ui/extenv/extenv-escaped-var.stderr
+++ b/tests/ui/extenv/extenv-escaped-var.stderr
@@ -7,5 +7,5 @@ LL |     env!("\t");
    = help: use `std::env::var("\t")` to read the variable at run time
    = note: this error originates in the macro `env` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-no-args.stderr b/tests/ui/extenv/extenv-no-args.stderr
index 70b85932c23..36d485676c2 100644
--- a/tests/ui/extenv/extenv-no-args.stderr
+++ b/tests/ui/extenv/extenv-no-args.stderr
@@ -4,5 +4,5 @@ error: `env!()` takes 1 or 2 arguments
 LL | fn main() { env!(); }
    |             ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-not-defined-custom.stderr b/tests/ui/extenv/extenv-not-defined-custom.stderr
index e7da4e046ab..9b6e32bc95f 100644
--- a/tests/ui/extenv/extenv-not-defined-custom.stderr
+++ b/tests/ui/extenv/extenv-not-defined-custom.stderr
@@ -6,5 +6,5 @@ LL | fn main() { env!("__HOPEFULLY_NOT_DEFINED__", "my error message"); }
    |
    = note: this error originates in the macro `env` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-not-defined-default.stderr b/tests/ui/extenv/extenv-not-defined-default.stderr
index e3dce000530..5198818f89c 100644
--- a/tests/ui/extenv/extenv-not-defined-default.stderr
+++ b/tests/ui/extenv/extenv-not-defined-default.stderr
@@ -7,5 +7,5 @@ LL |     env!("CARGO__HOPEFULLY_NOT_DEFINED__");
    = help: Cargo sets build script variables at run time. Use `std::env::var("CARGO__HOPEFULLY_NOT_DEFINED__")` instead
    = note: this error originates in the macro `env` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-not-string-literal.stderr b/tests/ui/extenv/extenv-not-string-literal.stderr
index 342a9f7096e..85ed442e2fe 100644
--- a/tests/ui/extenv/extenv-not-string-literal.stderr
+++ b/tests/ui/extenv/extenv-not-string-literal.stderr
@@ -4,5 +4,5 @@ error: expected string literal
 LL | fn main() { env!(10, "two"); }
    |                  ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extenv/extenv-too-many-args.stderr b/tests/ui/extenv/extenv-too-many-args.stderr
index 47cf810b70d..c0fd5d57251 100644
--- a/tests/ui/extenv/extenv-too-many-args.stderr
+++ b/tests/ui/extenv/extenv-too-many-args.stderr
@@ -4,5 +4,5 @@ error: `env!()` takes 1 or 2 arguments
 LL | fn main() { env!("one", "two", "three"); }
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extern-flag/multiple-opts.stderr b/tests/ui/extern-flag/multiple-opts.stderr
index 5088fb1c4d2..0aaca5ee253 100644
--- a/tests/ui/extern-flag/multiple-opts.stderr
+++ b/tests/ui/extern-flag/multiple-opts.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `somedep`
 LL |     somedep::somefun();
    |     ^^^^^^^ use of undeclared crate or module `somedep`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/extern-flag/no-nounused.stderr b/tests/ui/extern-flag/no-nounused.stderr
index 6446c53236c..171079287f0 100644
--- a/tests/ui/extern-flag/no-nounused.stderr
+++ b/tests/ui/extern-flag/no-nounused.stderr
@@ -6,5 +6,5 @@ LL | fn main() {
    |
    = note: requested on the command line with `-D unused-crate-dependencies`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extern-flag/noprelude.stderr b/tests/ui/extern-flag/noprelude.stderr
index 57878721683..23b9b2fd94b 100644
--- a/tests/ui/extern-flag/noprelude.stderr
+++ b/tests/ui/extern-flag/noprelude.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `somedep`
 LL |     somedep::somefun();
    |     ^^^^^^^ use of undeclared crate or module `somedep`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/extern-flag/public-and-private.stderr b/tests/ui/extern-flag/public-and-private.stderr
index 9dfc10effcf..209f5d4dadc 100644
--- a/tests/ui/extern-flag/public-and-private.stderr
+++ b/tests/ui/extern-flag/public-and-private.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(exported_private_dependencies)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extern/extern-const.stderr b/tests/ui/extern/extern-const.stderr
index a296751994e..4c2c3d6e0a8 100644
--- a/tests/ui/extern/extern-const.stderr
+++ b/tests/ui/extern/extern-const.stderr
@@ -8,5 +8,5 @@ LL |     const rust_dbg_static_mut: libc::c_int;
    |
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extern/extern-crate-rename.stderr b/tests/ui/extern/extern-crate-rename.stderr
index 5f147795521..43f6e56ab0e 100644
--- a/tests/ui/extern/extern-crate-rename.stderr
+++ b/tests/ui/extern/extern-crate-rename.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate m2 as other_m1;
    | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/extern/extern-ffi-fn-with-body.stderr b/tests/ui/extern/extern-ffi-fn-with-body.stderr
index 079c9cecd8e..dc34490b39a 100644
--- a/tests/ui/extern/extern-ffi-fn-with-body.stderr
+++ b/tests/ui/extern/extern-ffi-fn-with-body.stderr
@@ -14,5 +14,5 @@ LL | |     }
    = help: you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extern/extern-macro.stderr b/tests/ui/extern/extern-macro.stderr
index 5b7a720736a..e4d767f0e86 100644
--- a/tests/ui/extern/extern-macro.stderr
+++ b/tests/ui/extern/extern-macro.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: partially resolved path in a macro
 LL |     let _ = Foo::bar!();
    |             ^^^^^^^^ partially resolved path in a macro
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/extern/extern-main-fn.stderr b/tests/ui/extern/extern-main-fn.stderr
index 846102670a8..fd4e67e893e 100644
--- a/tests/ui/extern/extern-main-fn.stderr
+++ b/tests/ui/extern/extern-main-fn.stderr
@@ -7,6 +7,6 @@ LL | extern "C" fn main() {}
    = note: expected signature `fn()`
               found signature `extern "C" fn()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0580`.
diff --git a/tests/ui/extern/extern-main-issue-86110.stderr b/tests/ui/extern/extern-main-issue-86110.stderr
index 18dfddc46bd..8a3262fbcc7 100644
--- a/tests/ui/extern/extern-main-issue-86110.stderr
+++ b/tests/ui/extern/extern-main-issue-86110.stderr
@@ -4,5 +4,5 @@ error: the `main` function cannot be declared in an `extern` block
 LL |     fn main();
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extern/extern-type-diag-not-similar.stderr b/tests/ui/extern/extern-type-diag-not-similar.stderr
index 75836f7eca1..3547f9b3ff6 100644
--- a/tests/ui/extern/extern-type-diag-not-similar.stderr
+++ b/tests/ui/extern/extern-type-diag-not-similar.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `assert_send`
 LL | fn assert_send<T: Send + ?Sized>() {}
    |                   ^^^^ required by this bound in `assert_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/extern/extern-types-distinct-types.stderr b/tests/ui/extern/extern-types-distinct-types.stderr
index 3e6dc5cefad..ea4e51862f3 100644
--- a/tests/ui/extern/extern-types-distinct-types.stderr
+++ b/tests/ui/extern/extern-types-distinct-types.stderr
@@ -14,6 +14,6 @@ LL |     r
    = note: expected reference `&B`
               found reference `&A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/extern/extern-with-type-bounds.stderr b/tests/ui/extern/extern-with-type-bounds.stderr
index 88be1e5dd3d..42448d9e924 100644
--- a/tests/ui/extern/extern-with-type-bounds.stderr
+++ b/tests/ui/extern/extern-with-type-bounds.stderr
@@ -4,6 +4,6 @@ error[E0405]: cannot find trait `NoSuchTrait` in this scope
 LL |     fn align_of<T: NoSuchTrait>() -> usize;
    |                    ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/extern/extern-wrong-value-type.stderr b/tests/ui/extern/extern-wrong-value-type.stderr
index 463cee83169..1c08aa1717f 100644
--- a/tests/ui/extern/extern-wrong-value-type.stderr
+++ b/tests/ui/extern/extern-wrong-value-type.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `is_fn`
 LL | fn is_fn<F>(_: F) where F: Fn() {}
    |                            ^^^^ required by this bound in `is_fn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/extern/issue-28324.mir.stderr b/tests/ui/extern/issue-28324.mir.stderr
index aff8bf7927d..9376ac35e21 100644
--- a/tests/ui/extern/issue-28324.mir.stderr
+++ b/tests/ui/extern/issue-28324.mir.stderr
@@ -6,6 +6,6 @@ LL | pub static BAZ: u32 = *&error_message_count;
    |
    = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/extern/issue-28324.thir.stderr b/tests/ui/extern/issue-28324.thir.stderr
index c696c359830..8857f379ad1 100644
--- a/tests/ui/extern/issue-28324.thir.stderr
+++ b/tests/ui/extern/issue-28324.thir.stderr
@@ -6,6 +6,6 @@ LL | pub static BAZ: u32 = *&error_message_count;
    |
    = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/extern/issue-36122-accessing-externed-dst.stderr b/tests/ui/extern/issue-36122-accessing-externed-dst.stderr
index 5f78775f540..25348b64002 100644
--- a/tests/ui/extern/issue-36122-accessing-externed-dst.stderr
+++ b/tests/ui/extern/issue-36122-accessing-externed-dst.stderr
@@ -6,6 +6,6 @@ LL |         static symbol: [usize];
    |
    = help: the trait `Sized` is not implemented for `[usize]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/extoption_env-no-args.stderr b/tests/ui/extoption_env-no-args.stderr
index 65067942b85..d40f905b665 100644
--- a/tests/ui/extoption_env-no-args.stderr
+++ b/tests/ui/extoption_env-no-args.stderr
@@ -4,5 +4,5 @@ error: option_env! takes 1 argument
 LL | fn main() { option_env!(); }
    |             ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extoption_env-not-string-literal.stderr b/tests/ui/extoption_env-not-string-literal.stderr
index 272751916f5..d4fec1b45c9 100644
--- a/tests/ui/extoption_env-not-string-literal.stderr
+++ b/tests/ui/extoption_env-not-string-literal.stderr
@@ -4,5 +4,5 @@ error: argument must be a string literal
 LL | fn main() { option_env!(10); }
    |                         ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/extoption_env-too-many-args.stderr b/tests/ui/extoption_env-too-many-args.stderr
index a34e60b6448..c7aeaac75dd 100644
--- a/tests/ui/extoption_env-too-many-args.stderr
+++ b/tests/ui/extoption_env-too-many-args.stderr
@@ -4,5 +4,5 @@ error: option_env! takes 1 argument
 LL | fn main() { option_env!("one", "two"); }
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fail-simple.stderr b/tests/ui/fail-simple.stderr
index af8f54291ff..39fec3e2517 100644
--- a/tests/ui/fail-simple.stderr
+++ b/tests/ui/fail-simple.stderr
@@ -6,5 +6,5 @@ LL |     panic!(@);
    |
    = note: while trying to match end of macro
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/allow-features.stderr b/tests/ui/feature-gates/allow-features.stderr
index 9caf48dd138..ebd03e91c22 100644
--- a/tests/ui/feature-gates/allow-features.stderr
+++ b/tests/ui/feature-gates/allow-features.stderr
@@ -4,6 +4,6 @@ error[E0725]: the feature `unknown_stdlib_feature` is not in the list of allowed
 LL | #![feature(unknown_stdlib_feature)]
    |            ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0725`.
diff --git a/tests/ui/feature-gates/doc-rust-logo.stderr b/tests/ui/feature-gates/doc-rust-logo.stderr
index ff5855290d4..15398c8505f 100644
--- a/tests/ui/feature-gates/doc-rust-logo.stderr
+++ b/tests/ui/feature-gates/doc-rust-logo.stderr
@@ -7,6 +7,6 @@ LL | #![doc(rust_logo)]
    = note: see issue #90418 <https://github.com/rust-lang/rust/issues/90418> for more information
    = help: add `#![feature(rustdoc_internals)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr b/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr
index 1757befec35..3cc7b100db2 100644
--- a/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi_unadjusted.stderr
@@ -6,6 +6,6 @@ LL | extern "unadjusted" fn foo() {
    |
    = help: add `#![feature(abi_unadjusted)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-adt_const_params.stderr b/tests/ui/feature-gates/feature-gate-adt_const_params.stderr
index 13b9b84f0be..e6eeca2e098 100644
--- a/tests/ui/feature-gates/feature-gate-adt_const_params.stderr
+++ b/tests/ui/feature-gates/feature-gate-adt_const_params.stderr
@@ -7,5 +7,5 @@ LL | struct Foo<const NAME: &'static str>;
    = note: the only supported types are integers, `bool` and `char`
    = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-alloc-error-handler.stderr b/tests/ui/feature-gates/feature-gate-alloc-error-handler.stderr
index f414eb463df..1f22c8c5851 100644
--- a/tests/ui/feature-gates/feature-gate-alloc-error-handler.stderr
+++ b/tests/ui/feature-gates/feature-gate-alloc-error-handler.stderr
@@ -7,6 +7,6 @@ LL | #[alloc_error_handler]
    = note: see issue #51540 <https://github.com/rust-lang/rust/issues/51540> for more information
    = help: add `#![feature(alloc_error_handler)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-allocator_internals.stderr b/tests/ui/feature-gates/feature-gate-allocator_internals.stderr
index 6e276f7bccd..66a1c1be3f4 100644
--- a/tests/ui/feature-gates/feature-gate-allocator_internals.stderr
+++ b/tests/ui/feature-gates/feature-gate-allocator_internals.stderr
@@ -6,6 +6,6 @@ LL | #![default_lib_allocator]
    |
    = help: add `#![feature(allocator_internals)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-allow-internal-unsafe-nested-macro.stderr b/tests/ui/feature-gates/feature-gate-allow-internal-unsafe-nested-macro.stderr
index 4621bc0b30e..c2d29db6866 100644
--- a/tests/ui/feature-gates/feature-gate-allow-internal-unsafe-nested-macro.stderr
+++ b/tests/ui/feature-gates/feature-gate-allow-internal-unsafe-nested-macro.stderr
@@ -10,6 +10,6 @@ LL | bar!();
    = help: add `#![feature(allow_internal_unsafe)]` to the crate attributes to enable
    = note: this error originates in the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-nested-macro.stderr b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-nested-macro.stderr
index 1232d13a457..c0ab67025b2 100644
--- a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-nested-macro.stderr
+++ b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-nested-macro.stderr
@@ -10,6 +10,6 @@ LL | bar!();
    = help: add `#![feature(allow_internal_unstable)]` to the crate attributes to enable
    = note: this error originates in the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-allow-internal-unstable.stderr b/tests/ui/feature-gates/feature-gate-allow-internal-unstable.stderr
index 3c1a4bfc7d2..cb6cf4699fd 100644
--- a/tests/ui/feature-gates/feature-gate-allow-internal-unstable.stderr
+++ b/tests/ui/feature-gates/feature-gate-allow-internal-unstable.stderr
@@ -6,6 +6,6 @@ LL | #[allow_internal_unstable()]
    |
    = help: add `#![feature(allow_internal_unstable)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr b/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr
index 4a859430e04..9db088475a1 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr
@@ -7,6 +7,6 @@ LL |     asm!("");
    = note: see issue #93335 <https://github.com/rust-lang/rust/issues/93335> for more information
    = help: add `#![feature(asm_experimental_arch)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-asm_unwind.stderr b/tests/ui/feature-gates/feature-gate-asm_unwind.stderr
index 05e66acb556..eeabf7a5b0c 100644
--- a/tests/ui/feature-gates/feature-gate-asm_unwind.stderr
+++ b/tests/ui/feature-gates/feature-gate-asm_unwind.stderr
@@ -7,6 +7,6 @@ LL |         asm!("", options(may_unwind));
    = note: see issue #93334 <https://github.com/rust-lang/rust/issues/93334> for more information
    = help: add `#![feature(asm_unwind)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-assoc-type-defaults.stderr b/tests/ui/feature-gates/feature-gate-assoc-type-defaults.stderr
index 9edad615327..2ebaf40dcf6 100644
--- a/tests/ui/feature-gates/feature-gate-assoc-type-defaults.stderr
+++ b/tests/ui/feature-gates/feature-gate-assoc-type-defaults.stderr
@@ -7,6 +7,6 @@ LL |     type Bar = u8;
    = note: see issue #29661 <https://github.com/rust-lang/rust/issues/29661> for more information
    = help: add `#![feature(associated_type_defaults)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr b/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr
index 6563fbcba2e..a5f92b44c41 100644
--- a/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr
+++ b/tests/ui/feature-gates/feature-gate-associated_const_equality.stderr
@@ -7,6 +7,6 @@ LL | fn foo<A: TraitWAssocConst<A=32>>() {}
    = note: see issue #92827 <https://github.com/rust-lang/rust/issues/92827> for more information
    = help: add `#![feature(associated_const_equality)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-box_patterns.stderr b/tests/ui/feature-gates/feature-gate-box_patterns.stderr
index 601ec46a443..da15f698b75 100644
--- a/tests/ui/feature-gates/feature-gate-box_patterns.stderr
+++ b/tests/ui/feature-gates/feature-gate-box_patterns.stderr
@@ -7,6 +7,6 @@ LL |     let box x = Box::new('c');
    = note: see issue #29641 <https://github.com/rust-lang/rust/issues/29641> for more information
    = help: add `#![feature(box_patterns)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-builtin_syntax.stderr b/tests/ui/feature-gates/feature-gate-builtin_syntax.stderr
index 3bc7848f66d..6601d4cb417 100644
--- a/tests/ui/feature-gates/feature-gate-builtin_syntax.stderr
+++ b/tests/ui/feature-gates/feature-gate-builtin_syntax.stderr
@@ -7,6 +7,6 @@ LL |     builtin # offset_of(Foo, v);
    = note: see issue #110680 <https://github.com/rust-lang/rust/issues/110680> for more information
    = help: add `#![feature(builtin_syntax)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.stderr b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
index 7b3af8d994f..a439f297ba3 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.stderr
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
@@ -7,6 +7,6 @@ LL | pub unsafe extern "C" fn test(_: i32, ap: ...) { }
    = note: see issue #44930 <https://github.com/rust-lang/rust/issues/44930> for more information
    = help: add `#![feature(c_variadic)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-cfg-relocation-model.stderr b/tests/ui/feature-gates/feature-gate-cfg-relocation-model.stderr
index 592768a4203..bd43e190513 100644
--- a/tests/ui/feature-gates/feature-gate-cfg-relocation-model.stderr
+++ b/tests/ui/feature-gates/feature-gate-cfg-relocation-model.stderr
@@ -7,6 +7,6 @@ LL | #[cfg(relocation_model = "pic")]
    = note: see issue #114929 <https://github.com/rust-lang/rust/issues/114929> for more information
    = help: add `#![feature(cfg_relocation_model)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr b/tests/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr
index af59c714147..3400808bb72 100644
--- a/tests/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr
+++ b/tests/ui/feature-gates/feature-gate-cfg-target-thread-local.stderr
@@ -7,6 +7,6 @@ LL |     #[cfg_attr(target_thread_local, thread_local)]
    = note: see issue #29594 <https://github.com/rust-lang/rust/issues/29594> for more information
    = help: add `#![feature(cfg_target_thread_local)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-cfg_overflow_checks.stderr b/tests/ui/feature-gates/feature-gate-cfg_overflow_checks.stderr
index 79aba7945f6..22f9af8390d 100644
--- a/tests/ui/feature-gates/feature-gate-cfg_overflow_checks.stderr
+++ b/tests/ui/feature-gates/feature-gate-cfg_overflow_checks.stderr
@@ -7,6 +7,6 @@ LL | #[cfg(overflow_checks)]
    = note: see issue #111466 <https://github.com/rust-lang/rust/issues/111466> for more information
    = help: add `#![feature(cfg_overflow_checks)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-cfg_sanitize.stderr b/tests/ui/feature-gates/feature-gate-cfg_sanitize.stderr
index 8088585da8d..b53fc3acdbc 100644
--- a/tests/ui/feature-gates/feature-gate-cfg_sanitize.stderr
+++ b/tests/ui/feature-gates/feature-gate-cfg_sanitize.stderr
@@ -7,6 +7,6 @@ LL | #[cfg(not(sanitize = "thread"))]
    = note: see issue #39699 <https://github.com/rust-lang/rust/issues/39699> for more information
    = help: add `#![feature(cfg_sanitize)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-cfi_encoding.stderr b/tests/ui/feature-gates/feature-gate-cfi_encoding.stderr
index b10a1508881..04b20649940 100644
--- a/tests/ui/feature-gates/feature-gate-cfi_encoding.stderr
+++ b/tests/ui/feature-gates/feature-gate-cfi_encoding.stderr
@@ -7,6 +7,6 @@ LL | #[cfi_encoding = "3Bar"]
    = note: see issue #89653 <https://github.com/rust-lang/rust/issues/89653> for more information
    = help: add `#![feature(cfi_encoding)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-collapse_debuginfo.stderr b/tests/ui/feature-gates/feature-gate-collapse_debuginfo.stderr
index 2cbde893af9..f0b8fd1f373 100644
--- a/tests/ui/feature-gates/feature-gate-collapse_debuginfo.stderr
+++ b/tests/ui/feature-gates/feature-gate-collapse_debuginfo.stderr
@@ -7,6 +7,6 @@ LL | #[collapse_debuginfo]
    = note: see issue #100758 <https://github.com/rust-lang/rust/issues/100758> for more information
    = help: add `#![feature(collapse_debuginfo)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-compiler-builtins.stderr b/tests/ui/feature-gates/feature-gate-compiler-builtins.stderr
index 9d04aef8621..eadc4ddcb28 100644
--- a/tests/ui/feature-gates/feature-gate-compiler-builtins.stderr
+++ b/tests/ui/feature-gates/feature-gate-compiler-builtins.stderr
@@ -6,6 +6,6 @@ LL | #![compiler_builtins]
    |
    = help: add `#![feature(compiler_builtins)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-concat_bytes.stderr b/tests/ui/feature-gates/feature-gate-concat_bytes.stderr
index 4b3ee4c19ce..69b196335da 100644
--- a/tests/ui/feature-gates/feature-gate-concat_bytes.stderr
+++ b/tests/ui/feature-gates/feature-gate-concat_bytes.stderr
@@ -7,6 +7,6 @@ LL |     let a = concat_bytes!(b'A', b"BC");
    = note: see issue #87555 <https://github.com/rust-lang/rust/issues/87555> for more information
    = help: add `#![feature(concat_bytes)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-custom_mir.stderr b/tests/ui/feature-gates/feature-gate-custom_mir.stderr
index 3c149d30d82..f0f67adcca5 100644
--- a/tests/ui/feature-gates/feature-gate-custom_mir.stderr
+++ b/tests/ui/feature-gates/feature-gate-custom_mir.stderr
@@ -6,6 +6,6 @@ LL | #[custom_mir(dialect = "built")]
    |
    = help: add `#![feature(custom_mir)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-decl_macro.stderr b/tests/ui/feature-gates/feature-gate-decl_macro.stderr
index 800caf25239..94b609f0526 100644
--- a/tests/ui/feature-gates/feature-gate-decl_macro.stderr
+++ b/tests/ui/feature-gates/feature-gate-decl_macro.stderr
@@ -7,6 +7,6 @@ LL | macro m() {}
    = note: see issue #39412 <https://github.com/rust-lang/rust/issues/39412> for more information
    = help: add `#![feature(decl_macro)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-cell.stderr b/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-cell.stderr
index ce06ce916a7..e727b69ffce 100644
--- a/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-cell.stderr
+++ b/tests/ui/feature-gates/feature-gate-dispatch-from-dyn-cell.stderr
@@ -7,6 +7,6 @@ LL |     fn cell(self: Cell<&Self>);
    = note: type of `self` must be `Self` or a type that dereferences to it
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0307`.
diff --git a/tests/ui/feature-gates/feature-gate-doc_cfg.stderr b/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
index fe88e08c123..1a313a86f7c 100644
--- a/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
+++ b/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
@@ -7,6 +7,6 @@ LL | #[doc(cfg(unix))]
    = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
    = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-doc_masked.stderr b/tests/ui/feature-gates/feature-gate-doc_masked.stderr
index 80522b6eee5..96377d8d036 100644
--- a/tests/ui/feature-gates/feature-gate-doc_masked.stderr
+++ b/tests/ui/feature-gates/feature-gate-doc_masked.stderr
@@ -7,6 +7,6 @@ LL | #[doc(masked)]
    = note: see issue #44027 <https://github.com/rust-lang/rust/issues/44027> for more information
    = help: add `#![feature(doc_masked)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-doc_notable_trait.stderr b/tests/ui/feature-gates/feature-gate-doc_notable_trait.stderr
index 1f9bef40c4e..d19d3fa0ff7 100644
--- a/tests/ui/feature-gates/feature-gate-doc_notable_trait.stderr
+++ b/tests/ui/feature-gates/feature-gate-doc_notable_trait.stderr
@@ -7,6 +7,6 @@ LL | #[doc(notable_trait)]
    = note: see issue #45040 <https://github.com/rust-lang/rust/issues/45040> for more information
    = help: add `#![feature(doc_notable_trait)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr b/tests/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
index 6d7f4844a99..4a0c8d7fdc3 100644
--- a/tests/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
+++ b/tests/ui/feature-gates/feature-gate-exclusive-range-pattern.stderr
@@ -7,6 +7,6 @@ LL |         0 .. 3 => {}
    = note: see issue #37854 <https://github.com/rust-lang/rust/issues/37854> for more information
    = help: add `#![feature(exclusive_range_pattern)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-exhaustive-patterns.stderr b/tests/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
index 49e7ab6082c..d34f257c8d9 100644
--- a/tests/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
+++ b/tests/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
@@ -12,6 +12,6 @@ help: you might want to use `let else` to handle the variant that isn't matched
 LL |     let Ok(_x) = foo() else { todo!() };
    |                        ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/feature-gates/feature-gate-extern_prelude.stderr b/tests/ui/feature-gates/feature-gate-extern_prelude.stderr
index d72e47e9ed8..3b0ffae8696 100644
--- a/tests/ui/feature-gates/feature-gate-extern_prelude.stderr
+++ b/tests/ui/feature-gates/feature-gate-extern_prelude.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `::`, found `-`
 LL | can-only-test-this-in-run-make-fulldeps
    |    ^ expected one of `!` or `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-extern_types.stderr b/tests/ui/feature-gates/feature-gate-extern_types.stderr
index 923fae400a9..17ce01fd59b 100644
--- a/tests/ui/feature-gates/feature-gate-extern_types.stderr
+++ b/tests/ui/feature-gates/feature-gate-extern_types.stderr
@@ -7,6 +7,6 @@ LL |     type T;
    = note: see issue #43467 <https://github.com/rust-lang/rust/issues/43467> for more information
    = help: add `#![feature(extern_types)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-feature-gate.stderr b/tests/ui/feature-gates/feature-gate-feature-gate.stderr
index ad97741dae4..8ff99ddbe21 100644
--- a/tests/ui/feature-gates/feature-gate-feature-gate.stderr
+++ b/tests/ui/feature-gates/feature-gate-feature-gate.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![forbid(unstable_features)]
    |           ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-ffi_const.stderr b/tests/ui/feature-gates/feature-gate-ffi_const.stderr
index bed6a2ce488..c86606f3352 100644
--- a/tests/ui/feature-gates/feature-gate-ffi_const.stderr
+++ b/tests/ui/feature-gates/feature-gate-ffi_const.stderr
@@ -7,6 +7,6 @@ LL |     #[ffi_const]
    = note: see issue #58328 <https://github.com/rust-lang/rust/issues/58328> for more information
    = help: add `#![feature(ffi_const)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-ffi_pure.stderr b/tests/ui/feature-gates/feature-gate-ffi_pure.stderr
index 2b0308fd661..4392fb16deb 100644
--- a/tests/ui/feature-gates/feature-gate-ffi_pure.stderr
+++ b/tests/ui/feature-gates/feature-gate-ffi_pure.stderr
@@ -7,6 +7,6 @@ LL |     #[ffi_pure]
    = note: see issue #58329 <https://github.com/rust-lang/rust/issues/58329> for more information
    = help: add `#![feature(ffi_pure)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-ffi_returns_twice.stderr b/tests/ui/feature-gates/feature-gate-ffi_returns_twice.stderr
index 3585355ab77..7a030d45460 100644
--- a/tests/ui/feature-gates/feature-gate-ffi_returns_twice.stderr
+++ b/tests/ui/feature-gates/feature-gate-ffi_returns_twice.stderr
@@ -7,6 +7,6 @@ LL |     #[ffi_returns_twice]
    = note: see issue #58314 <https://github.com/rust-lang/rust/issues/58314> for more information
    = help: add `#![feature(ffi_returns_twice)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-fn_align.stderr b/tests/ui/feature-gates/feature-gate-fn_align.stderr
index 5ff124e48dc..3351ceaf2f0 100644
--- a/tests/ui/feature-gates/feature-gate-fn_align.stderr
+++ b/tests/ui/feature-gates/feature-gate-fn_align.stderr
@@ -7,6 +7,6 @@ LL | #[repr(align(16))]
    = note: see issue #82232 <https://github.com/rust-lang/rust/issues/82232> for more information
    = help: add `#![feature(fn_align)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-fn_delegation.stderr b/tests/ui/feature-gates/feature-gate-fn_delegation.stderr
index 1f55c1f250a..14d85c5263e 100644
--- a/tests/ui/feature-gates/feature-gate-fn_delegation.stderr
+++ b/tests/ui/feature-gates/feature-gate-fn_delegation.stderr
@@ -9,5 +9,5 @@ LL | todo!();
    |
    = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-format_args_nl.stderr b/tests/ui/feature-gates/feature-gate-format_args_nl.stderr
index b211e2f8ed8..35a712aad8a 100644
--- a/tests/ui/feature-gates/feature-gate-format_args_nl.stderr
+++ b/tests/ui/feature-gates/feature-gate-format_args_nl.stderr
@@ -6,6 +6,6 @@ LL |     format_args_nl!("");
    |
    = help: add `#![feature(format_args_nl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-fundamental.stderr b/tests/ui/feature-gates/feature-gate-fundamental.stderr
index 1ae8d9128b1..14ee169bdaa 100644
--- a/tests/ui/feature-gates/feature-gate-fundamental.stderr
+++ b/tests/ui/feature-gates/feature-gate-fundamental.stderr
@@ -7,6 +7,6 @@ LL | #[fundamental]
    = note: see issue #29635 <https://github.com/rust-lang/rust/issues/29635> for more information
    = help: add `#![feature(fundamental)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-gen_blocks.none.stderr b/tests/ui/feature-gates/feature-gate-gen_blocks.none.stderr
index b448c35e846..56f8309a69f 100644
--- a/tests/ui/feature-gates/feature-gate-gen_blocks.none.stderr
+++ b/tests/ui/feature-gates/feature-gate-gen_blocks.none.stderr
@@ -4,6 +4,6 @@ error[E0422]: cannot find struct, variant or union type `gen` in this scope
 LL |     gen {};
    |     ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/feature-gates/feature-gate-generic_associated_types_extended.stderr b/tests/ui/feature-gates/feature-gate-generic_associated_types_extended.stderr
index bb1622628dc..e5265b67eab 100644
--- a/tests/ui/feature-gates/feature-gate-generic_associated_types_extended.stderr
+++ b/tests/ui/feature-gates/feature-gate-generic_associated_types_extended.stderr
@@ -6,6 +6,6 @@ LL | #[rustc_error]
    |
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-imported_main.stderr b/tests/ui/feature-gates/feature-gate-imported_main.stderr
index 3b879fdfc6b..94cb74047c8 100644
--- a/tests/ui/feature-gates/feature-gate-imported_main.stderr
+++ b/tests/ui/feature-gates/feature-gate-imported_main.stderr
@@ -7,6 +7,6 @@ LL | use foo::bar as main;
    = note: see issue #28937 <https://github.com/rust-lang/rust/issues/28937> for more information
    = help: add `#![feature(imported_main)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-inherent_associated_types.stderr b/tests/ui/feature-gates/feature-gate-inherent_associated_types.stderr
index 76e65d239f8..8e117422a79 100644
--- a/tests/ui/feature-gates/feature-gate-inherent_associated_types.stderr
+++ b/tests/ui/feature-gates/feature-gate-inherent_associated_types.stderr
@@ -7,6 +7,6 @@ LL |     type Bar = isize;
    = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
    = help: add `#![feature(inherent_associated_types)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-inline_const.stderr b/tests/ui/feature-gates/feature-gate-inline_const.stderr
index be2f567155c..3cb4aad003f 100644
--- a/tests/ui/feature-gates/feature-gate-inline_const.stderr
+++ b/tests/ui/feature-gates/feature-gate-inline_const.stderr
@@ -7,6 +7,6 @@ LL |     let _ = const {
    = note: see issue #76001 <https://github.com/rust-lang/rust/issues/76001> for more information
    = help: add `#![feature(inline_const)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-inline_const_pat.stderr b/tests/ui/feature-gates/feature-gate-inline_const_pat.stderr
index ca533d8505c..eab024dde66 100644
--- a/tests/ui/feature-gates/feature-gate-inline_const_pat.stderr
+++ b/tests/ui/feature-gates/feature-gate-inline_const_pat.stderr
@@ -7,6 +7,6 @@ LL |     let const { () } = ();
    = note: see issue #76001 <https://github.com/rust-lang/rust/issues/76001> for more information
    = help: add `#![feature(inline_const_pat)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-large-assignments.stderr b/tests/ui/feature-gates/feature-gate-large-assignments.stderr
index 8ddc3043e96..c025be4f636 100644
--- a/tests/ui/feature-gates/feature-gate-large-assignments.stderr
+++ b/tests/ui/feature-gates/feature-gate-large-assignments.stderr
@@ -7,6 +7,6 @@ LL | #![move_size_limit = "42"]
    = note: see issue #83518 <https://github.com/rust-lang/rust/issues/83518> for more information
    = help: add `#![feature(large_assignments)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-link_cfg.stderr b/tests/ui/feature-gates/feature-gate-link_cfg.stderr
index 97b6cbca412..6e42be3954d 100644
--- a/tests/ui/feature-gates/feature-gate-link_cfg.stderr
+++ b/tests/ui/feature-gates/feature-gate-link_cfg.stderr
@@ -6,6 +6,6 @@ LL | #[link(name = "foo", cfg(foo))]
    |
    = help: add `#![feature(link_cfg)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr b/tests/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr
index 6bce5b823f3..0cad260a14a 100644
--- a/tests/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr
+++ b/tests/ui/feature-gates/feature-gate-link_llvm_intrinsics.stderr
@@ -7,6 +7,6 @@ LL |     fn sqrt(x: f32) -> f32;
    = note: see issue #29602 <https://github.com/rust-lang/rust/issues/29602> for more information
    = help: add `#![feature(link_llvm_intrinsics)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-linkage.stderr b/tests/ui/feature-gates/feature-gate-linkage.stderr
index a1c73e555ef..ca1f5414568 100644
--- a/tests/ui/feature-gates/feature-gate-linkage.stderr
+++ b/tests/ui/feature-gates/feature-gate-linkage.stderr
@@ -7,6 +7,6 @@ LL |     #[linkage = "extern_weak"] static foo: *mut isize;
    = note: see issue #29603 <https://github.com/rust-lang/rust/issues/29603> for more information
    = help: add `#![feature(linkage)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-log_syntax.stderr b/tests/ui/feature-gates/feature-gate-log_syntax.stderr
index fdc1c855347..500c752e20d 100644
--- a/tests/ui/feature-gates/feature-gate-log_syntax.stderr
+++ b/tests/ui/feature-gates/feature-gate-log_syntax.stderr
@@ -7,6 +7,6 @@ LL |     log_syntax!()
    = note: see issue #29598 <https://github.com/rust-lang/rust/issues/29598> for more information
    = help: add `#![feature(log_syntax)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-log_syntax2.stderr b/tests/ui/feature-gates/feature-gate-log_syntax2.stderr
index 6deb4a46cd5..a808a9463a0 100644
--- a/tests/ui/feature-gates/feature-gate-log_syntax2.stderr
+++ b/tests/ui/feature-gates/feature-gate-log_syntax2.stderr
@@ -7,6 +7,6 @@ LL |     println!("{:?}", log_syntax!());
    = note: see issue #29598 <https://github.com/rust-lang/rust/issues/29598> for more information
    = help: add `#![feature(log_syntax)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-marker_trait_attr.stderr b/tests/ui/feature-gates/feature-gate-marker_trait_attr.stderr
index e3c3756fd21..4555ef1874f 100644
--- a/tests/ui/feature-gates/feature-gate-marker_trait_attr.stderr
+++ b/tests/ui/feature-gates/feature-gate-marker_trait_attr.stderr
@@ -7,6 +7,6 @@ LL | #[marker] trait ExplicitMarker {}
    = note: see issue #29864 <https://github.com/rust-lang/rust/issues/29864> for more information
    = help: add `#![feature(marker_trait_attr)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-may-dangle.stderr b/tests/ui/feature-gates/feature-gate-may-dangle.stderr
index d47a76a50ef..c12b3ba517d 100644
--- a/tests/ui/feature-gates/feature-gate-may-dangle.stderr
+++ b/tests/ui/feature-gates/feature-gate-may-dangle.stderr
@@ -7,6 +7,6 @@ LL | unsafe impl<#[may_dangle] A> Drop for Pt<A> {
    = note: see issue #34761 <https://github.com/rust-lang/rust/issues/34761> for more information
    = help: add `#![feature(dropck_eyepatch)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.stderr b/tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.stderr
index 2ef6a1c0404..4c7ae9e2ef5 100644
--- a/tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.stderr
+++ b/tests/ui/feature-gates/feature-gate-native_link_modifiers_as_needed.stderr
@@ -7,6 +7,6 @@ LL | #[link(name = "foo", kind = "dylib", modifiers = "+as-needed")]
    = note: see issue #81490 <https://github.com/rust-lang/rust/issues/81490> for more information
    = help: add `#![feature(native_link_modifiers_as_needed)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-needs-allocator.stderr b/tests/ui/feature-gates/feature-gate-needs-allocator.stderr
index 2b213acebb5..ca21f222588 100644
--- a/tests/ui/feature-gates/feature-gate-needs-allocator.stderr
+++ b/tests/ui/feature-gates/feature-gate-needs-allocator.stderr
@@ -6,6 +6,6 @@ LL | #![needs_allocator]
    |
    = help: add `#![feature(allocator_internals)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-negative_bounds.stderr b/tests/ui/feature-gates/feature-gate-negative_bounds.stderr
index ae010fdf3f8..74b9e4bc4c8 100644
--- a/tests/ui/feature-gates/feature-gate-negative_bounds.stderr
+++ b/tests/ui/feature-gates/feature-gate-negative_bounds.stderr
@@ -4,5 +4,5 @@ error: negative bounds are not supported
 LL | fn test<T: !Copy>() {}
    |            ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-no_core.stderr b/tests/ui/feature-gates/feature-gate-no_core.stderr
index 8430a9ec6a7..e525c95ac36 100644
--- a/tests/ui/feature-gates/feature-gate-no_core.stderr
+++ b/tests/ui/feature-gates/feature-gate-no_core.stderr
@@ -7,6 +7,6 @@ LL | #![no_core]
    = note: see issue #29639 <https://github.com/rust-lang/rust/issues/29639> for more information
    = help: add `#![feature(no_core)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-no_sanitize.stderr b/tests/ui/feature-gates/feature-gate-no_sanitize.stderr
index 3993357006f..bb808961eb2 100644
--- a/tests/ui/feature-gates/feature-gate-no_sanitize.stderr
+++ b/tests/ui/feature-gates/feature-gate-no_sanitize.stderr
@@ -7,6 +7,6 @@ LL | #[no_sanitize(address)]
    = note: see issue #39699 <https://github.com/rust-lang/rust/issues/39699> for more information
    = help: add `#![feature(no_sanitize)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-non_exhaustive_omitted_patterns_lint.stderr b/tests/ui/feature-gates/feature-gate-non_exhaustive_omitted_patterns_lint.stderr
index 8af0eedc82b..a5333713977 100644
--- a/tests/ui/feature-gates/feature-gate-non_exhaustive_omitted_patterns_lint.stderr
+++ b/tests/ui/feature-gates/feature-gate-non_exhaustive_omitted_patterns_lint.stderr
@@ -192,6 +192,6 @@ LL |     #[warn(non_exhaustive_omitted_patterns)]
    = help: add `#![feature(non_exhaustive_omitted_patterns_lint)]` to the crate attributes to enable
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error; 16 warnings emitted
+error: aborting due to 1 previous error; 16 warnings emitted
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/feature-gates/feature-gate-non_lifetime_binders.stderr b/tests/ui/feature-gates/feature-gate-non_lifetime_binders.stderr
index 01c8ee30c5f..f727fdae90e 100644
--- a/tests/ui/feature-gates/feature-gate-non_lifetime_binders.stderr
+++ b/tests/ui/feature-gates/feature-gate-non_lifetime_binders.stderr
@@ -7,6 +7,6 @@ LL | fn foo() where for<T> T:, {}
    = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
    = help: add `#![feature(non_lifetime_binders)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-omit-gdb-pretty-printer-section.stderr b/tests/ui/feature-gates/feature-gate-omit-gdb-pretty-printer-section.stderr
index a5ec3599f6a..86f6040b14f 100644
--- a/tests/ui/feature-gates/feature-gate-omit-gdb-pretty-printer-section.stderr
+++ b/tests/ui/feature-gates/feature-gate-omit-gdb-pretty-printer-section.stderr
@@ -6,6 +6,6 @@ LL | #[omit_gdb_pretty_printer_section]
    |
    = help: add `#![feature(omit_gdb_pretty_printer_section)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-overlapping_marker_traits.stderr b/tests/ui/feature-gates/feature-gate-overlapping_marker_traits.stderr
index 0526c6dc839..fe9a88b5ebb 100644
--- a/tests/ui/feature-gates/feature-gate-overlapping_marker_traits.stderr
+++ b/tests/ui/feature-gates/feature-gate-overlapping_marker_traits.stderr
@@ -6,6 +6,6 @@ LL | impl<T: Display> MyMarker for T {}
 LL | impl<T: Debug> MyMarker for T {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/feature-gates/feature-gate-prelude_import.stderr b/tests/ui/feature-gates/feature-gate-prelude_import.stderr
index 8686aed8f82..b2e2a7c8cc1 100644
--- a/tests/ui/feature-gates/feature-gate-prelude_import.stderr
+++ b/tests/ui/feature-gates/feature-gate-prelude_import.stderr
@@ -6,6 +6,6 @@ LL | #[prelude_import]
    |
    = help: add `#![feature(prelude_import)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-proc_macro_byte_character.stderr b/tests/ui/feature-gates/feature-gate-proc_macro_byte_character.stderr
index 00691538938..f8fa8c54198 100644
--- a/tests/ui/feature-gates/feature-gate-proc_macro_byte_character.stderr
+++ b/tests/ui/feature-gates/feature-gate-proc_macro_byte_character.stderr
@@ -7,6 +7,6 @@ LL |     Literal::byte_character(b'a');
    = note: see issue #115268 <https://github.com/rust-lang/rust/issues/115268> for more information
    = help: add `#![feature(proc_macro_byte_character)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-profiler-runtime.stderr b/tests/ui/feature-gates/feature-gate-profiler-runtime.stderr
index 18e6503c552..cc6506c5680 100644
--- a/tests/ui/feature-gates/feature-gate-profiler-runtime.stderr
+++ b/tests/ui/feature-gates/feature-gate-profiler-runtime.stderr
@@ -6,6 +6,6 @@ LL | #![profiler_runtime]
    |
    = help: add `#![feature(profiler_runtime)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-register_tool.stderr b/tests/ui/feature-gates/feature-gate-register_tool.stderr
index 9ffaaa8de7a..d72249e0212 100644
--- a/tests/ui/feature-gates/feature-gate-register_tool.stderr
+++ b/tests/ui/feature-gates/feature-gate-register_tool.stderr
@@ -7,6 +7,6 @@ LL | #![register_tool(tool)]
    = note: see issue #66079 <https://github.com/rust-lang/rust/issues/66079> for more information
    = help: add `#![feature(register_tool)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-repr128.stderr b/tests/ui/feature-gates/feature-gate-repr128.stderr
index 3999a6d2d2f..657802632b0 100644
--- a/tests/ui/feature-gates/feature-gate-repr128.stderr
+++ b/tests/ui/feature-gates/feature-gate-repr128.stderr
@@ -7,6 +7,6 @@ LL | enum A {
    = note: see issue #56071 <https://github.com/rust-lang/rust/issues/56071> for more information
    = help: add `#![feature(repr128)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-rustc-allow-const-fn-unstable.stderr b/tests/ui/feature-gates/feature-gate-rustc-allow-const-fn-unstable.stderr
index a549cb64e0c..b33721ca43d 100644
--- a/tests/ui/feature-gates/feature-gate-rustc-allow-const-fn-unstable.stderr
+++ b/tests/ui/feature-gates/feature-gate-rustc-allow-const-fn-unstable.stderr
@@ -7,6 +7,6 @@ LL | #[rustc_allow_const_fn_unstable()]
    = note: see issue #69399 <https://github.com/rust-lang/rust/issues/69399> for more information
    = help: add `#![feature(rustc_allow_const_fn_unstable)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-rustc_const_unstable.stderr b/tests/ui/feature-gates/feature-gate-rustc_const_unstable.stderr
index 48493b786d6..869764fa456 100644
--- a/tests/ui/feature-gates/feature-gate-rustc_const_unstable.stderr
+++ b/tests/ui/feature-gates/feature-gate-rustc_const_unstable.stderr
@@ -4,6 +4,6 @@ error[E0734]: stability attributes may not be used outside of the standard libra
 LL | #[rustc_const_unstable(feature="fzzzzzt")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0734`.
diff --git a/tests/ui/feature-gates/feature-gate-simd.stderr b/tests/ui/feature-gates/feature-gate-simd.stderr
index 6e0e0b2703a..fa30d461f9c 100644
--- a/tests/ui/feature-gates/feature-gate-simd.stderr
+++ b/tests/ui/feature-gates/feature-gate-simd.stderr
@@ -7,6 +7,6 @@ LL | #[repr(simd)]
    = note: see issue #27731 <https://github.com/rust-lang/rust/issues/27731> for more information
    = help: add `#![feature(repr_simd)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-start.stderr b/tests/ui/feature-gates/feature-gate-start.stderr
index eec9d1a2924..157bf18c9e8 100644
--- a/tests/ui/feature-gates/feature-gate-start.stderr
+++ b/tests/ui/feature-gates/feature-gate-start.stderr
@@ -7,6 +7,6 @@ LL | fn foo(_: isize, _: *const *const u8) -> isize { 0 }
    = note: see issue #29633 <https://github.com/rust-lang/rust/issues/29633> for more information
    = help: add `#![feature(start)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr b/tests/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr
index 57ffaed78f5..4ff85dc0797 100644
--- a/tests/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr
+++ b/tests/ui/feature-gates/feature-gate-stmt_expr_attributes.stderr
@@ -7,6 +7,6 @@ LL | const X: i32 = #[allow(dead_code)] 8;
    = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
    = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-thread_local.stderr b/tests/ui/feature-gates/feature-gate-thread_local.stderr
index 6352e908708..8fbbfb59a48 100644
--- a/tests/ui/feature-gates/feature-gate-thread_local.stderr
+++ b/tests/ui/feature-gates/feature-gate-thread_local.stderr
@@ -7,6 +7,6 @@ LL | #[thread_local]
    = note: see issue #29594 <https://github.com/rust-lang/rust/issues/29594> for more information
    = help: add `#![feature(thread_local)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-trace_macros.stderr b/tests/ui/feature-gates/feature-gate-trace_macros.stderr
index 3978d4111bb..305186e5117 100644
--- a/tests/ui/feature-gates/feature-gate-trace_macros.stderr
+++ b/tests/ui/feature-gates/feature-gate-trace_macros.stderr
@@ -7,6 +7,6 @@ LL |     trace_macros!(true);
    = note: see issue #29598 <https://github.com/rust-lang/rust/issues/29598> for more information
    = help: add `#![feature(trace_macros)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-trait-alias.stderr b/tests/ui/feature-gates/feature-gate-trait-alias.stderr
index 41cd6dbd8bc..919a97673fb 100644
--- a/tests/ui/feature-gates/feature-gate-trait-alias.stderr
+++ b/tests/ui/feature-gates/feature-gate-trait-alias.stderr
@@ -7,6 +7,6 @@ LL | trait Foo = Default;
    = note: see issue #41517 <https://github.com/rust-lang/rust/issues/41517> for more information
    = help: add `#![feature(trait_alias)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-transparent_unions.stderr b/tests/ui/feature-gates/feature-gate-transparent_unions.stderr
index 65c8fe05229..13ea3603a8d 100644
--- a/tests/ui/feature-gates/feature-gate-transparent_unions.stderr
+++ b/tests/ui/feature-gates/feature-gate-transparent_unions.stderr
@@ -7,6 +7,6 @@ LL | union OkButUnstableUnion {
    = note: see issue #60405 <https://github.com/rust-lang/rust/issues/60405> for more information
    = help: add `#![feature(transparent_unions)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-try_blocks.stderr b/tests/ui/feature-gates/feature-gate-try_blocks.stderr
index 022409f9556..028dff34c9d 100644
--- a/tests/ui/feature-gates/feature-gate-try_blocks.stderr
+++ b/tests/ui/feature-gates/feature-gate-try_blocks.stderr
@@ -11,6 +11,6 @@ LL | |     };
    = note: see issue #31436 <https://github.com/rust-lang/rust/issues/31436> for more information
    = help: add `#![feature(try_blocks)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-type_ascription.stderr b/tests/ui/feature-gates/feature-gate-type_ascription.stderr
index d747aea6d17..2c78e4e3832 100644
--- a/tests/ui/feature-gates/feature-gate-type_ascription.stderr
+++ b/tests/ui/feature-gates/feature-gate-type_ascription.stderr
@@ -7,6 +7,6 @@ LL |     let a = type_ascribe!(10, u8);
    = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
    = help: add `#![feature(type_ascription)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-unix_sigpipe.stderr b/tests/ui/feature-gates/feature-gate-unix_sigpipe.stderr
index cf3284467f7..6fbade424b8 100644
--- a/tests/ui/feature-gates/feature-gate-unix_sigpipe.stderr
+++ b/tests/ui/feature-gates/feature-gate-unix_sigpipe.stderr
@@ -7,6 +7,6 @@ LL | #[unix_sigpipe = "inherit"]
    = note: see issue #97889 <https://github.com/rust-lang/rust/issues/97889> for more information
    = help: add `#![feature(unix_sigpipe)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-unsafe_pin_internals.stderr b/tests/ui/feature-gates/feature-gate-unsafe_pin_internals.stderr
index 39afbf2db7e..fc9bcd90e52 100644
--- a/tests/ui/feature-gates/feature-gate-unsafe_pin_internals.stderr
+++ b/tests/ui/feature-gates/feature-gate-unsafe_pin_internals.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![forbid(internal_features, unsafe_code)]
    |           ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-unsized_locals.stderr b/tests/ui/feature-gates/feature-gate-unsized_locals.stderr
index 9aeeb88cf04..f1595e034be 100644
--- a/tests/ui/feature-gates/feature-gate-unsized_locals.stderr
+++ b/tests/ui/feature-gates/feature-gate-unsized_locals.stderr
@@ -15,6 +15,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn f(f: &dyn FnOnce()) {}
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr b/tests/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr
index bea6cee0a89..dd5a1cd89e7 100644
--- a/tests/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr
+++ b/tests/ui/feature-gates/feature-gate-unsized_tuple_coercion.stderr
@@ -7,6 +7,6 @@ LL |     let _ : &(dyn Send,) = &((),);
    = note: see issue #42877 <https://github.com/rust-lang/rust/issues/42877> for more information
    = help: add `#![feature(unsized_tuple_coercion)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-with_negative_coherence.stderr b/tests/ui/feature-gates/feature-gate-with_negative_coherence.stderr
index d4c201b5d3e..ba076568088 100644
--- a/tests/ui/feature-gates/feature-gate-with_negative_coherence.stderr
+++ b/tests/ui/feature-gates/feature-gate-with_negative_coherence.stderr
@@ -7,6 +7,6 @@ LL |
 LL | impl<T> Foo for &T { }
    | ^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr b/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr
index 218e0292776..0053d9d5cff 100644
--- a/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr
+++ b/tests/ui/feature-gates/feature-gated-feature-in-macro-arg.stderr
@@ -6,6 +6,6 @@ LL |         extern "rust-intrinsic" {
    |
    = help: add `#![feature(intrinsics)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/issue-49983-see-issue-0.stderr b/tests/ui/feature-gates/issue-49983-see-issue-0.stderr
index 314238a34df..5f9e5d440fb 100644
--- a/tests/ui/feature-gates/issue-49983-see-issue-0.stderr
+++ b/tests/ui/feature-gates/issue-49983-see-issue-0.stderr
@@ -6,6 +6,6 @@ LL | #[allow(unused_imports)] use core::ptr::Unique;
    |
    = help: add `#![feature(ptr_internals)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/rustc-private.stderr b/tests/ui/feature-gates/rustc-private.stderr
index 1a8536d37d6..7419af80a32 100644
--- a/tests/ui/feature-gates/rustc-private.stderr
+++ b/tests/ui/feature-gates/rustc-private.stderr
@@ -7,6 +7,6 @@ LL | extern crate libc;
    = note: see issue #27812 <https://github.com/rust-lang/rust/issues/27812> for more information
    = help: add `#![feature(rustc_private)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/unknown-feature.stderr b/tests/ui/feature-gates/unknown-feature.stderr
index e5c05872dbf..0a731ddcc0b 100644
--- a/tests/ui/feature-gates/unknown-feature.stderr
+++ b/tests/ui/feature-gates/unknown-feature.stderr
@@ -4,6 +4,6 @@ error[E0635]: unknown feature `unknown_rust_feature`
 LL | #![feature(unknown_rust_feature)]
    |            ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0635`.
diff --git a/tests/ui/ffi_const2.stderr b/tests/ui/ffi_const2.stderr
index 0c30c9dc50c..b8cbc296370 100644
--- a/tests/ui/ffi_const2.stderr
+++ b/tests/ui/ffi_const2.stderr
@@ -4,6 +4,6 @@ error[E0757]: `#[ffi_const]` function cannot be `#[ffi_pure]`
 LL |     #[ffi_pure]
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0757`.
diff --git a/tests/ui/fmt/closing-brace-as-fill.stderr b/tests/ui/fmt/closing-brace-as-fill.stderr
index aa1e5aff652..70068fa3aad 100644
--- a/tests/ui/fmt/closing-brace-as-fill.stderr
+++ b/tests/ui/fmt/closing-brace-as-fill.stderr
@@ -8,5 +8,5 @@ LL |     println!("Hello, world! {0:}<3", 2);
    |
    = note: the character `'}'` is interpreted as a fill character because of the `:` that precedes it
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr b/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr
index bb6a14d88b3..950dea721e2 100644
--- a/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr
+++ b/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr
@@ -8,5 +8,5 @@ LL |     format_string_proc_macro::bad_format_args_captures!();
    = note: to avoid ambiguity, `format_args!` cannot capture variables when the format string is expanded from a macro
    = note: this error originates in the macro `concat` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/format-raw-string-error.stderr b/tests/ui/fmt/format-raw-string-error.stderr
index 8d61950d8c2..090ca9353a7 100644
--- a/tests/ui/fmt/format-raw-string-error.stderr
+++ b/tests/ui/fmt/format-raw-string-error.stderr
@@ -6,5 +6,5 @@ LL |     println!(r#"\'\'\'\'\'\'\'\'\'\'\'\'\'\'}"#);
    |
    = note: if you intended to print `}`, you can escape it using `}}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/ifmt-unimpl.stderr b/tests/ui/fmt/ifmt-unimpl.stderr
index 4c0ac52865d..c0650ff17c5 100644
--- a/tests/ui/fmt/ifmt-unimpl.stderr
+++ b/tests/ui/fmt/ifmt-unimpl.stderr
@@ -21,6 +21,6 @@ note: required by a bound in `core::fmt::rt::Argument::<'a>::new_upper_hex`
   --> $SRC_DIR/core/src/fmt/rt.rs:LL:COL
    = note: this error originates in the macro `$crate::__export::format_args` which comes from the expansion of the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/fmt/ifmt-unknown-trait.stderr b/tests/ui/fmt/ifmt-unknown-trait.stderr
index 459432bf4e4..66147ae45fa 100644
--- a/tests/ui/fmt/ifmt-unknown-trait.stderr
+++ b/tests/ui/fmt/ifmt-unknown-trait.stderr
@@ -15,5 +15,5 @@ LL |     format!("{:notimplemented}", "3");
            - `x`, which uses the `LowerHex` trait
            - `X`, which uses the `UpperHex` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/issue-104142.stderr b/tests/ui/fmt/issue-104142.stderr
index d41644faa28..690ccb8d08b 100644
--- a/tests/ui/fmt/issue-104142.stderr
+++ b/tests/ui/fmt/issue-104142.stderr
@@ -6,5 +6,5 @@ LL |     \"\'}､"#
    |
    = note: if you intended to print `}`, you can escape it using `}}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/issue-75307.stderr b/tests/ui/fmt/issue-75307.stderr
index c5b0b11e7d0..986e805d4f9 100644
--- a/tests/ui/fmt/issue-75307.stderr
+++ b/tests/ui/fmt/issue-75307.stderr
@@ -4,5 +4,5 @@ error: 3 positional arguments in format string, but there is 1 argument
 LL |     format!(r"{}{}{}", named_arg=1);
    |               ^^^^^^             -
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/issue-86085.stderr b/tests/ui/fmt/issue-86085.stderr
index ee7d8a5cc23..f325a3ce293 100644
--- a/tests/ui/fmt/issue-86085.stderr
+++ b/tests/ui/fmt/issue-86085.stderr
@@ -7,5 +7,5 @@ LL | format ! ( concat ! ( r#"lJ𐏿Æ�.𐏿�"# , "r} {}" )     ) ;
    = note: if you intended to print `}`, you can escape it using `}}`
    = note: this error originates in the macro `concat` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/issue-89173.stderr b/tests/ui/fmt/issue-89173.stderr
index ddeb769eadc..62ca8862d21 100644
--- a/tests/ui/fmt/issue-89173.stderr
+++ b/tests/ui/fmt/issue-89173.stderr
@@ -14,5 +14,5 @@ LL |     print!("%0*x", width, num);
    |             ^^^^
    = note: printf formatting is not supported; see the documentation for `std::fmt`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fmt/issue-91556.stderr b/tests/ui/fmt/issue-91556.stderr
index dbd5aef458b..beab3db0d94 100644
--- a/tests/ui/fmt/issue-91556.stderr
+++ b/tests/ui/fmt/issue-91556.stderr
@@ -7,5 +7,5 @@ LL |   let _ = format!(concat!("{0}𝖳𝖾𝗌𝗍{"), i);
    = note: if you intended to print `{`, you can escape it using `{{`
    = note: this error originates in the macro `concat` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fn-in-pat.stderr b/tests/ui/fn-in-pat.stderr
index 2482d632695..41ea4df72a2 100644
--- a/tests/ui/fn-in-pat.stderr
+++ b/tests/ui/fn-in-pat.stderr
@@ -6,6 +6,6 @@ LL |         A::new() => (),
    |
    = help: for more information, visit https://doc.rust-lang.org/book/ch18-00-patterns.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0164`.
diff --git a/tests/ui/fn/bad-main.stderr b/tests/ui/fn/bad-main.stderr
index 65140a0794f..47aa02c09af 100644
--- a/tests/ui/fn/bad-main.stderr
+++ b/tests/ui/fn/bad-main.stderr
@@ -7,6 +7,6 @@ LL | fn main(x: isize) { }
    = note: expected signature `fn()`
               found signature `fn(isize)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0580`.
diff --git a/tests/ui/fn/fn-bad-block-type.stderr b/tests/ui/fn/fn-bad-block-type.stderr
index 13ebfd1e203..6917bea6591 100644
--- a/tests/ui/fn/fn-bad-block-type.stderr
+++ b/tests/ui/fn/fn-bad-block-type.stderr
@@ -6,6 +6,6 @@ LL | fn f() -> isize { true }
    |           |
    |           expected `isize` because of return type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/fn/fn-closure-mutable-capture.stderr b/tests/ui/fn/fn-closure-mutable-capture.stderr
index 03e3d545a99..5a2f92250e0 100644
--- a/tests/ui/fn/fn-closure-mutable-capture.stderr
+++ b/tests/ui/fn/fn-closure-mutable-capture.stderr
@@ -10,6 +10,6 @@ LL |     bar(move || x = 1);
    |     |   in this closure
    |     expects `Fn` instead of `FnMut`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type-2.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type-2.stderr
index 0c3df04eabc..e57b5af82cd 100644
--- a/tests/ui/fn/implied-bounds-unnorm-associated-type-2.stderr
+++ b/tests/ui/fn/implied-bounds-unnorm-associated-type-2.stderr
@@ -13,5 +13,5 @@ LL |     f::<'a, 'b>(());
    = note: the function `f` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr
index 4df639232a3..3be630e2b23 100644
--- a/tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr
+++ b/tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr
@@ -11,6 +11,6 @@ LL |
 LL |     println!("{}", y);
    |                    - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
index 3f6401b9f7a..4662eb32abb 100644
--- a/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
+++ b/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
@@ -16,6 +16,6 @@ help: consider adding an explicit lifetime bound
 LL | impl<'a, T: 'a> Trait<'a> for T {
    |           ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type.stderr
index d417f288393..c2a8fa741ca 100644
--- a/tests/ui/fn/implied-bounds-unnorm-associated-type.stderr
+++ b/tests/ui/fn/implied-bounds-unnorm-associated-type.stderr
@@ -11,6 +11,6 @@ LL |
 LL |     println!("{}", y);
    |                    - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/fn/issue-3044.stderr b/tests/ui/fn/issue-3044.stderr
index 219029e2afd..06254775b74 100644
--- a/tests/ui/fn/issue-3044.stderr
+++ b/tests/ui/fn/issue-3044.stderr
@@ -16,6 +16,6 @@ LL +
 LL ~     }, /* f */);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/fn/issue-3099.stderr b/tests/ui/fn/issue-3099.stderr
index 32ee2e1d207..4417f232665 100644
--- a/tests/ui/fn/issue-3099.stderr
+++ b/tests/ui/fn/issue-3099.stderr
@@ -9,6 +9,6 @@ LL | fn a(x: String, y: String) -> String {
    |
    = note: `a` must be defined only once in the value namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/fn/issue-39259.stderr b/tests/ui/fn/issue-39259.stderr
index b656b76bfe4..bd102e58135 100644
--- a/tests/ui/fn/issue-39259.stderr
+++ b/tests/ui/fn/issue-39259.stderr
@@ -10,6 +10,6 @@ help: parenthesized trait syntax expands to `Fn<(u32,), Output=u32>`
 LL | impl Fn(u32) -> u32 for S {
    |      ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/fn/signature-error-reporting-under-verbose.stderr b/tests/ui/fn/signature-error-reporting-under-verbose.stderr
index 067ee824d5d..6c6a313c4df 100644
--- a/tests/ui/fn/signature-error-reporting-under-verbose.stderr
+++ b/tests/ui/fn/signature-error-reporting-under-verbose.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn needs_ptr(_: fn(i32, u32)) {}
    |    ^^^^^^^^^ ---------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/for/for-c-in-str.stderr b/tests/ui/for/for-c-in-str.stderr
index 959a7c43fff..475cf8c8874 100644
--- a/tests/ui/for/for-c-in-str.stderr
+++ b/tests/ui/for/for-c-in-str.stderr
@@ -7,6 +7,6 @@ LL |     for c in "asdf" {
    = help: the trait `Iterator` is not implemented for `&str`
    = note: required for `&str` to implement `IntoIterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/for/for-else-err.stderr b/tests/ui/for/for-else-err.stderr
index b330d107647..bd49dc47244 100644
--- a/tests/ui/for/for-else-err.stderr
+++ b/tests/ui/for/for-else-err.stderr
@@ -13,5 +13,5 @@ LL | |     }
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/for/for-else-let-else-err.stderr b/tests/ui/for/for-else-let-else-err.stderr
index a2396a8fbb1..bb6558739ba 100644
--- a/tests/ui/for/for-else-let-else-err.stderr
+++ b/tests/ui/for/for-else-let-else-err.stderr
@@ -13,5 +13,5 @@ LL | |     };
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/for/for-expn.stderr b/tests/ui/for/for-expn.stderr
index cdb21155527..00822324039 100644
--- a/tests/ui/for/for-expn.stderr
+++ b/tests/ui/for/for-expn.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `foo` in this scope
 LL |       foo
    |       ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/for/for-loop-bogosity.stderr b/tests/ui/for/for-loop-bogosity.stderr
index 9bf8056e82e..194a2fa08ce 100644
--- a/tests/ui/for/for-loop-bogosity.stderr
+++ b/tests/ui/for/for-loop-bogosity.stderr
@@ -7,6 +7,6 @@ LL |     for x in bogus {
    = help: the trait `Iterator` is not implemented for `MyStruct`
    = note: required for `MyStruct` to implement `IntoIterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/for/for-loop-refutable-pattern-error-message.stderr b/tests/ui/for/for-loop-refutable-pattern-error-message.stderr
index 49a82a6769d..2082603d2fb 100644
--- a/tests/ui/for/for-loop-refutable-pattern-error-message.stderr
+++ b/tests/ui/for/for-loop-refutable-pattern-error-message.stderr
@@ -6,6 +6,6 @@ LL |     for &1 in [1].iter() {}
    |
    = note: the matched value is of type `&i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/for/for-loop-type-error.stderr b/tests/ui/for/for-loop-type-error.stderr
index c93a3b9b25c..393becd1b34 100644
--- a/tests/ui/for/for-loop-type-error.stderr
+++ b/tests/ui/for/for-loop-type-error.stderr
@@ -6,6 +6,6 @@ LL |     let x = () + ();
    |             |
    |             ()
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/for/for-loop-unconstrained-element-type.stderr b/tests/ui/for/for-loop-unconstrained-element-type.stderr
index b1b38f6b919..3add3ae2eeb 100644
--- a/tests/ui/for/for-loop-unconstrained-element-type.stderr
+++ b/tests/ui/for/for-loop-unconstrained-element-type.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     for i in Vec::<T>::new() { }
    |                 +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/for/issue-20605.current.stderr b/tests/ui/for/issue-20605.current.stderr
index b9a53cbd4fc..c8d39afdeb9 100644
--- a/tests/ui/for/issue-20605.current.stderr
+++ b/tests/ui/for/issue-20605.current.stderr
@@ -11,6 +11,6 @@ help: consider mutably borrowing here
 LL |     for item in &mut *things { *item = 0 }
    |                 ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/foreign-fn-return-lifetime.stderr b/tests/ui/foreign-fn-return-lifetime.stderr
index df1a23a19ed..43edcbde35c 100644
--- a/tests/ui/foreign-fn-return-lifetime.stderr
+++ b/tests/ui/foreign-fn-return-lifetime.stderr
@@ -10,6 +10,6 @@ help: consider using the `'static` lifetime
 LL |     pub fn f() -> &'static u8;
    |                    +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/foreign/issue-74120-lowering-of-ffi-block-bodies.stderr b/tests/ui/foreign/issue-74120-lowering-of-ffi-block-bodies.stderr
index d4a9ca3e7c6..564ee146687 100644
--- a/tests/ui/foreign/issue-74120-lowering-of-ffi-block-bodies.stderr
+++ b/tests/ui/foreign/issue-74120-lowering-of-ffi-block-bodies.stderr
@@ -15,5 +15,5 @@ LL | |     }
    = help: you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/foreign/issue-91370-foreign-fn-block-impl.stderr b/tests/ui/foreign/issue-91370-foreign-fn-block-impl.stderr
index 4fb2f8c659c..fea2ab61e92 100644
--- a/tests/ui/foreign/issue-91370-foreign-fn-block-impl.stderr
+++ b/tests/ui/foreign/issue-91370-foreign-fn-block-impl.stderr
@@ -17,5 +17,5 @@ LL | |     }
    = help: you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/fully-qualified-type/fully-qualified-type-name1.stderr b/tests/ui/fully-qualified-type/fully-qualified-type-name1.stderr
index 258a8d16393..7497e48c5d2 100644
--- a/tests/ui/fully-qualified-type/fully-qualified-type-name1.stderr
+++ b/tests/ui/fully-qualified-type/fully-qualified-type-name1.stderr
@@ -15,6 +15,6 @@ help: try wrapping the expression in `Some`
 LL |     x = Some(5);
    |         +++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/fully-qualified-type/fully-qualified-type-name2.stderr b/tests/ui/fully-qualified-type/fully-qualified-type-name2.stderr
index c7c0846595d..af716916548 100644
--- a/tests/ui/fully-qualified-type/fully-qualified-type-name2.stderr
+++ b/tests/ui/fully-qualified-type/fully-qualified-type-name2.stderr
@@ -18,6 +18,6 @@ note: `y::Foo` is defined in module `crate::y` of the current crate
 LL |     pub enum Foo { }
    |     ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/fully-qualified-type/fully-qualified-type-name4.stderr b/tests/ui/fully-qualified-type/fully-qualified-type-name4.stderr
index 6b312202bfe..45634131ad3 100644
--- a/tests/ui/fully-qualified-type/fully-qualified-type-name4.stderr
+++ b/tests/ui/fully-qualified-type/fully-qualified-type-name4.stderr
@@ -13,6 +13,6 @@ help: try wrapping the expression in `Some`
 LL |     return Some(x);
    |            +++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/functional-struct-update/functional-struct-update-noncopyable.stderr b/tests/ui/functional-struct-update/functional-struct-update-noncopyable.stderr
index 45cdd3d2ddc..16808f29dac 100644
--- a/tests/ui/functional-struct-update/functional-struct-update-noncopyable.stderr
+++ b/tests/ui/functional-struct-update/functional-struct-update-noncopyable.stderr
@@ -7,6 +7,6 @@ LL |     let _b = A { y: Arc::new(3), ..a };
    |              cannot move out of here
    |              move occurs because `a.x` has type `Arc<isize>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0509`.
diff --git a/tests/ui/functional-struct-update/functional-struct-update-respects-privacy.stderr b/tests/ui/functional-struct-update/functional-struct-update-respects-privacy.stderr
index 0b8af90b418..692d98bc53c 100644
--- a/tests/ui/functional-struct-update/functional-struct-update-respects-privacy.stderr
+++ b/tests/ui/functional-struct-update/functional-struct-update-respects-privacy.stderr
@@ -4,6 +4,6 @@ error[E0451]: field `secret_uid` of struct `S` is private
 LL |     let s_2 = foo::S { b: format!("ess two"), ..s_1 }; // FRU ...
    |                                                 ^^^ field `secret_uid` is private
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0451`.
diff --git a/tests/ui/future-incompatible-lint-group.stderr b/tests/ui/future-incompatible-lint-group.stderr
index a8fb100a749..161fe82e373 100644
--- a/tests/ui/future-incompatible-lint-group.stderr
+++ b/tests/ui/future-incompatible-lint-group.stderr
@@ -24,5 +24,5 @@ LL | #![deny(future_incompatible)]
    |         ^^^^^^^^^^^^^^^^^^^
    = note: `#[deny(invalid_doc_attributes)]` implied by `#[deny(future_incompatible)]`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/generic-associated-types/assume-gat-normalization-for-nested-goals.stderr b/tests/ui/generic-associated-types/assume-gat-normalization-for-nested-goals.stderr
index abad0f25c0f..685c2794967 100644
--- a/tests/ui/generic-associated-types/assume-gat-normalization-for-nested-goals.stderr
+++ b/tests/ui/generic-associated-types/assume-gat-normalization-for-nested-goals.stderr
@@ -19,6 +19,6 @@ help: consider further restricting the associated type
 LL | trait Foo where <Self as Foo>::Bar<()>: Eq<i32> {
    |           +++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
index 362aeae2361..5dfc42bc873 100644
--- a/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
+++ b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
@@ -15,6 +15,6 @@ note: due to current limitations in the borrow checker, this implies a `'static`
 LL |     for<'a> I::Item<'a>: Debug,
    |                          ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/generic-associated-types/bugs/hrtb-implied-2.stderr b/tests/ui/generic-associated-types/bugs/hrtb-implied-2.stderr
index 1ee270398de..9a1a09b29df 100644
--- a/tests/ui/generic-associated-types/bugs/hrtb-implied-2.stderr
+++ b/tests/ui/generic-associated-types/bugs/hrtb-implied-2.stderr
@@ -17,6 +17,6 @@ LL |     let _next = iter2.next();
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
    = note: due to current limitations in the borrow checker, this implies a `'static` lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/generic-associated-types/bugs/hrtb-implied-3.stderr b/tests/ui/generic-associated-types/bugs/hrtb-implied-3.stderr
index c67e02437cd..77f363ee87d 100644
--- a/tests/ui/generic-associated-types/bugs/hrtb-implied-3.stderr
+++ b/tests/ui/generic-associated-types/bugs/hrtb-implied-3.stderr
@@ -17,6 +17,6 @@ note: due to current limitations in the borrow checker, this implies a `'static`
 LL |     for<'a> I::Item<'a>: Sized,
    |                          ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-87735.stderr b/tests/ui/generic-associated-types/bugs/issue-87735.stderr
index ebe2054ce5e..b80e3e798bd 100644
--- a/tests/ui/generic-associated-types/bugs/issue-87735.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-87735.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `U` is not constrained by the impl trait, self
 LL | impl<'b, T, U> AsRef2 for Foo<T>
    |             ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-87755.stderr b/tests/ui/generic-associated-types/bugs/issue-87755.stderr
index 5e94db9b0c0..e16312dbb27 100644
--- a/tests/ui/generic-associated-types/bugs/issue-87755.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-87755.stderr
@@ -4,6 +4,6 @@ error[E0275]: overflow evaluating the requirement `<Bar as Foo>::Ass == _`
 LL |     type Ass = Bar;
    |                ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-87803.stderr b/tests/ui/generic-associated-types/bugs/issue-87803.stderr
index fe2abdedbf3..31ed47749a8 100644
--- a/tests/ui/generic-associated-types/bugs/issue-87803.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-87803.stderr
@@ -7,6 +7,6 @@ LL |     fn scan<'a>(&mut self, i : Self::Input<'a>) -> Self::Token<'a>;
 LL |     fn scan<'a>(&mut self, s : &'a str) -> &'a str {
    |            ^^^^ lifetimes do not match method in trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0195`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-88382.stderr b/tests/ui/generic-associated-types/bugs/issue-88382.stderr
index a9a70bb7130..624fe2799e0 100644
--- a/tests/ui/generic-associated-types/bugs/issue-88382.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-88382.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `do_something`
 LL | fn do_something<I: Iterable>(i: I, mut f: impl for<'a> Fn(&mut I::Iterator<'a>)) {
    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `do_something`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-88460.stderr b/tests/ui/generic-associated-types/bugs/issue-88460.stderr
index b9e2c4186c1..74418a0c0bd 100644
--- a/tests/ui/generic-associated-types/bugs/issue-88460.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-88460.stderr
@@ -24,6 +24,6 @@ LL | fn test<T>(value: T)
 LL |     for<'a> T::Assoc<'a>: Marker,
    |                           ^^^^^^ required by this bound in `test`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-88526.stderr b/tests/ui/generic-associated-types/bugs/issue-88526.stderr
index 56857c6550b..ba87ac9185d 100644
--- a/tests/ui/generic-associated-types/bugs/issue-88526.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-88526.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `I` is not constrained by the impl trait, self
 LL | impl<'q, Q, I, F> A for TestB<Q, F>
    |             ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/generic-associated-types/bugs/issue-91762.stderr b/tests/ui/generic-associated-types/bugs/issue-91762.stderr
index 1045e80f046..b4ca65889ad 100644
--- a/tests/ui/generic-associated-types/bugs/issue-91762.stderr
+++ b/tests/ui/generic-associated-types/bugs/issue-91762.stderr
@@ -10,6 +10,6 @@ help: consider specifying the generic arguments
 LL |         ret = <Self::Base as Functor>::fmap::<T, U>(arg);
    |                                            ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/generic-associated-types/collections-project-default.stderr b/tests/ui/generic-associated-types/collections-project-default.stderr
index 3c3ae24dd47..db1deab92b8 100644
--- a/tests/ui/generic-associated-types/collections-project-default.stderr
+++ b/tests/ui/generic-associated-types/collections-project-default.stderr
@@ -11,6 +11,6 @@ LL |     res
               found associated type `<<C as Collection<i32>>::Family as CollectionFamily>::Member<f32>`
    = note: an associated type was expected, but a different one was found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/generic-associated-types/collectivity-regression.stderr b/tests/ui/generic-associated-types/collectivity-regression.stderr
index a085096e1f8..0c395a1664f 100644
--- a/tests/ui/generic-associated-types/collectivity-regression.stderr
+++ b/tests/ui/generic-associated-types/collectivity-regression.stderr
@@ -20,5 +20,5 @@ help: consider restricting the type parameter to the `'static` lifetime
 LL |     for<'a> T: Get<Value<'a> = ()> + 'static,
    |                                    +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/const_params_have_right_type.stderr b/tests/ui/generic-associated-types/const_params_have_right_type.stderr
index fdedd3bf5fb..78992112a7c 100644
--- a/tests/ui/generic-associated-types/const_params_have_right_type.stderr
+++ b/tests/ui/generic-associated-types/const_params_have_right_type.stderr
@@ -11,6 +11,6 @@ LL | impl Trait for () {
 LL |     type Foo<const N: u64> = u32;
    |              ^^^^^^^^^^^^ found const parameter of type `u64`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/generic-associated-types/constraint-assoc-type-suggestion.stderr b/tests/ui/generic-associated-types/constraint-assoc-type-suggestion.stderr
index 3b65b32f45d..54dbe28bd03 100644
--- a/tests/ui/generic-associated-types/constraint-assoc-type-suggestion.stderr
+++ b/tests/ui/generic-associated-types/constraint-assoc-type-suggestion.stderr
@@ -13,6 +13,6 @@ help: consider constraining the associated type `<T as X>::Y<i32>` to `Vec<i32>`
 LL | fn f<T: X<Y<i32> = Vec<i32>>>(a: T::Y<i32>) {
    |          +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/generic-associated-types/cross-crate-bounds.stderr b/tests/ui/generic-associated-types/cross-crate-bounds.stderr
index 83ee04d5a6c..ebd733c2ef1 100644
--- a/tests/ui/generic-associated-types/cross-crate-bounds.stderr
+++ b/tests/ui/generic-associated-types/cross-crate-bounds.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `foo_defn::Foo::Bar`
 LL |     type Bar: AsRef<()>;
    |               ^^^^^^^^^ required by this bound in `Foo::Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/empty_generics.stderr b/tests/ui/generic-associated-types/empty_generics.stderr
index b753181cf48..1ac35b318fd 100644
--- a/tests/ui/generic-associated-types/empty_generics.stderr
+++ b/tests/ui/generic-associated-types/empty_generics.stderr
@@ -9,5 +9,5 @@ LL |
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/extended/lending_iterator.base.stderr b/tests/ui/generic-associated-types/extended/lending_iterator.base.stderr
index 614c4a34c18..84210eeb1a6 100644
--- a/tests/ui/generic-associated-types/extended/lending_iterator.base.stderr
+++ b/tests/ui/generic-associated-types/extended/lending_iterator.base.stderr
@@ -7,6 +7,6 @@ LL |     fn from_iter<T: for<'x> LendingIterator<Item<'x> = A>>(iter: T) -> Self
 LL |     fn from_iter<I: for<'x> LendingIterator<Item<'x> = A>>(mut iter: I) -> Self {
    |                                             ^^^^^^^^^^^^ impl has extra requirement `I: 'x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/generic-associated-types/extended/lending_iterator_2.base.stderr b/tests/ui/generic-associated-types/extended/lending_iterator_2.base.stderr
index f6b0b644e40..717d867057e 100644
--- a/tests/ui/generic-associated-types/extended/lending_iterator_2.base.stderr
+++ b/tests/ui/generic-associated-types/extended/lending_iterator_2.base.stderr
@@ -7,6 +7,6 @@ LL |     fn from_iter<T: for<'x> LendingIterator<Item<'x> = A>>(iter: T) -> Self
 LL |     fn from_iter<I: for<'x> LendingIterator<Item<'x> = A>>(mut iter: I) -> Self {
    |                                             ^^^^^^^^^^^^ impl has extra requirement `I: 'x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/generic-associated-types/gat-bounds-not-checked-with-right-substitutions.stderr b/tests/ui/generic-associated-types/gat-bounds-not-checked-with-right-substitutions.stderr
index 7ea7a7b2de7..8ae308303b8 100644
--- a/tests/ui/generic-associated-types/gat-bounds-not-checked-with-right-substitutions.stderr
+++ b/tests/ui/generic-associated-types/gat-bounds-not-checked-with-right-substitutions.stderr
@@ -7,5 +7,5 @@ LL |     type Gat<'a> = &'a str;
    = note: `Lengthen<&'0 str>` would have to be implemented for the type `&'a str`, for any lifetime `'0`...
    = note: ...but `Lengthen<&'1 str>` is actually implemented for the type `&'1 str`, for some specific lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/gat-in-trait-path.base.stderr b/tests/ui/generic-associated-types/gat-in-trait-path.base.stderr
index 9013d429530..bd3728cec8c 100644
--- a/tests/ui/generic-associated-types/gat-in-trait-path.base.stderr
+++ b/tests/ui/generic-associated-types/gat-in-trait-path.base.stderr
@@ -16,6 +16,6 @@ LL |     type A<'a> where Self: 'a;
              Fooy
              Fooer<T>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/generic-associated-types/issue-101020.stderr b/tests/ui/generic-associated-types/issue-101020.stderr
index 91967fb8509..9c3753c2d18 100644
--- a/tests/ui/generic-associated-types/issue-101020.stderr
+++ b/tests/ui/generic-associated-types/issue-101020.stderr
@@ -23,6 +23,6 @@ LL |     fn consume<F>(self, _f: F)
 LL |         for<'a> Self::Item<'a>: FuncInput<'a, Self::Item<'a>>,
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `LendingIterator::consume`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-102114.current.stderr b/tests/ui/generic-associated-types/issue-102114.current.stderr
index 6e7a0b1f67f..69ae5676ee0 100644
--- a/tests/ui/generic-associated-types/issue-102114.current.stderr
+++ b/tests/ui/generic-associated-types/issue-102114.current.stderr
@@ -7,6 +7,6 @@ LL |     type B<'b>;
 LL |     type B<T> = Wrapper<T>;
    |            ^ found 1 type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0049`.
diff --git a/tests/ui/generic-associated-types/issue-102114.next.stderr b/tests/ui/generic-associated-types/issue-102114.next.stderr
index 6e7a0b1f67f..69ae5676ee0 100644
--- a/tests/ui/generic-associated-types/issue-102114.next.stderr
+++ b/tests/ui/generic-associated-types/issue-102114.next.stderr
@@ -7,6 +7,6 @@ LL |     type B<'b>;
 LL |     type B<T> = Wrapper<T>;
    |            ^ found 1 type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0049`.
diff --git a/tests/ui/generic-associated-types/issue-102335-gat.stderr b/tests/ui/generic-associated-types/issue-102335-gat.stderr
index 7a7900a1e65..39ca7954ede 100644
--- a/tests/ui/generic-associated-types/issue-102335-gat.stderr
+++ b/tests/ui/generic-associated-types/issue-102335-gat.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     type A: S<C<(), i32 = ()> = ()>;
    |                     ^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/generic-associated-types/issue-47206-where-clause.stderr b/tests/ui/generic-associated-types/issue-47206-where-clause.stderr
index 7006744df49..da0924312f1 100644
--- a/tests/ui/generic-associated-types/issue-47206-where-clause.stderr
+++ b/tests/ui/generic-associated-types/issue-47206-where-clause.stderr
@@ -7,6 +7,6 @@ LL |     type Assoc3<T>;
 LL |     type Assoc3<T> = Vec<T> where T: Iterator;
    |                                      ^^^^^^^^ impl has extra requirement `T: Iterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/generic-associated-types/issue-67510-pass.base.stderr b/tests/ui/generic-associated-types/issue-67510-pass.base.stderr
index 4cc68530ee1..f39d0055428 100644
--- a/tests/ui/generic-associated-types/issue-67510-pass.base.stderr
+++ b/tests/ui/generic-associated-types/issue-67510-pass.base.stderr
@@ -13,6 +13,6 @@ LL |     type Y<'a>;
    |          ^ ...because it contains the generic associated type `Y`
    = help: consider moving `Y` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr b/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
index 6bb7492af81..55901cf450b 100644
--- a/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
+++ b/tests/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::marker::Copy> UnsafeCopy for T {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr b/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
index 2376bda8190..6bf832bb9e2 100644
--- a/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
+++ b/tests/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
@@ -15,6 +15,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::ops::Fn<()>> Fun for T {
    |       ++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr b/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
index 2429531e4e5..d9f26ee6c29 100644
--- a/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
+++ b/tests/ui/generic-associated-types/issue-68643-broken-mir.stderr
@@ -15,6 +15,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::ops::Fn<()>> Fun for T {
    |       ++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr b/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
index 11221353a92..3dc9ff10243 100644
--- a/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
+++ b/tests/ui/generic-associated-types/issue-68644-codegen-selection.stderr
@@ -15,6 +15,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::ops::Fn<()>> Fun for T {
    |       ++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr b/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
index 52300efc2d8..45fb65f6cf1 100644
--- a/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
+++ b/tests/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
@@ -15,6 +15,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::ops::Fn<()>> Fun for T {
    |       ++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-68648-2.stderr b/tests/ui/generic-associated-types/issue-68648-2.stderr
index 0514e7bd6f6..d71ad870d3c 100644
--- a/tests/ui/generic-associated-types/issue-68648-2.stderr
+++ b/tests/ui/generic-associated-types/issue-68648-2.stderr
@@ -16,6 +16,6 @@ note: associated function defined here
 LL |     fn identity<'a>(t: Self::F<'a>) -> Self::F<'a> { t }
    |        ^^^^^^^^     --------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
index 20c07db4c04..ecb337bbceb 100644
--- a/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
+++ b/tests/ui/generic-associated-types/issue-68656-unsized-values.stderr
@@ -18,6 +18,6 @@ help: consider further restricting this bound
 LL | impl<T: Copy + std::ops::Deref<Target = T>> UnsafeCopy<T> for T {
    |                               ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/generic-associated-types/issue-71176.stderr b/tests/ui/generic-associated-types/issue-71176.stderr
index 4b4fe43e8c4..ed837f34753 100644
--- a/tests/ui/generic-associated-types/issue-71176.stderr
+++ b/tests/ui/generic-associated-types/issue-71176.stderr
@@ -14,6 +14,6 @@ help: add missing lifetime argument
 LL |   inner: Box<dyn Provider<A<'a> = B>>,
    |                            ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-74684-1.stderr b/tests/ui/generic-associated-types/issue-74684-1.stderr
index b93ee37987f..4bc13d7b289 100644
--- a/tests/ui/generic-associated-types/issue-74684-1.stderr
+++ b/tests/ui/generic-associated-types/issue-74684-1.stderr
@@ -14,6 +14,6 @@ LL |     let _x = T::identity(&a);
 LL | }
    | - `a` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/generic-associated-types/issue-74684-2.stderr b/tests/ui/generic-associated-types/issue-74684-2.stderr
index 59b85abf5c8..e50e3df85b3 100644
--- a/tests/ui/generic-associated-types/issue-74684-2.stderr
+++ b/tests/ui/generic-associated-types/issue-74684-2.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `bug`
 LL | fn bug<'a, T: ?Sized + Fun<F<'a> = [u8]>>(t: Box<T>) -> &'static T::F<'a> {
    |                            ^^^^^^^^^^^^ required by this bound in `bug`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/generic-associated-types/issue-76535.extended.stderr b/tests/ui/generic-associated-types/issue-76535.extended.stderr
index 369b86d2928..f6fe8b16902 100644
--- a/tests/ui/generic-associated-types/issue-76535.extended.stderr
+++ b/tests/ui/generic-associated-types/issue-76535.extended.stderr
@@ -14,6 +14,6 @@ help: add missing lifetime argument
 LL |     let sub: Box<dyn SuperTrait<SubType<'a> = SubStruct>> = Box::new(SuperStruct::new(0));
    |                                        ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-78671.extended.stderr b/tests/ui/generic-associated-types/issue-78671.extended.stderr
index 1d8a3d410f8..a5d56256d28 100644
--- a/tests/ui/generic-associated-types/issue-78671.extended.stderr
+++ b/tests/ui/generic-associated-types/issue-78671.extended.stderr
@@ -14,6 +14,6 @@ help: add missing generic argument
 LL |     Box::new(Family) as &dyn CollectionFamily<Member<T>=usize>
    |                                                     +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-79636-1.stderr b/tests/ui/generic-associated-types/issue-79636-1.stderr
index 6e0d2ff4ded..4076e951875 100644
--- a/tests/ui/generic-associated-types/issue-79636-1.stderr
+++ b/tests/ui/generic-associated-types/issue-79636-1.stderr
@@ -14,6 +14,6 @@ help: add missing generic argument
 LL |     MInner: Monad<Unwrapped = A, Wrapped<B> = MOuter::Wrapped<A>>,
    |                                         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-79636-2.stderr b/tests/ui/generic-associated-types/issue-79636-2.stderr
index 16287323995..a8b63f15079 100644
--- a/tests/ui/generic-associated-types/issue-79636-2.stderr
+++ b/tests/ui/generic-associated-types/issue-79636-2.stderr
@@ -14,6 +14,6 @@ help: add missing generic argument
 LL |     W: SomeTrait<Wrapped<A> = W>,
    |                         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-80433.stderr b/tests/ui/generic-associated-types/issue-80433.stderr
index 4f4f96a4b92..488fbeceddd 100644
--- a/tests/ui/generic-associated-types/issue-80433.stderr
+++ b/tests/ui/generic-associated-types/issue-80433.stderr
@@ -14,6 +14,6 @@ help: add missing lifetime argument
 LL | fn test_simpler<'a>(dst: &'a mut impl TestMut<Output<'a> = &'a mut f32>)
    |                                                     ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-81712-cyclic-traits.stderr b/tests/ui/generic-associated-types/issue-81712-cyclic-traits.stderr
index e0fc225f463..5eb988ea042 100644
--- a/tests/ui/generic-associated-types/issue-81712-cyclic-traits.stderr
+++ b/tests/ui/generic-associated-types/issue-81712-cyclic-traits.stderr
@@ -14,6 +14,6 @@ help: add missing generic argument
 LL |     type CType: C<DType<T> = Self>;
    |                        +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-81862.stderr b/tests/ui/generic-associated-types/issue-81862.stderr
index df30be65ec5..730dc8fffe8 100644
--- a/tests/ui/generic-associated-types/issue-81862.stderr
+++ b/tests/ui/generic-associated-types/issue-81862.stderr
@@ -14,6 +14,6 @@ help: add missing lifetime argument
 LL |     fn next(&mut self) -> Option<Self::Item<'_>>;
    |                                            ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/issue-87258_a.stderr b/tests/ui/generic-associated-types/issue-87258_a.stderr
index eae9bd9b16f..01f2a92f94a 100644
--- a/tests/ui/generic-associated-types/issue-87258_a.stderr
+++ b/tests/ui/generic-associated-types/issue-87258_a.stderr
@@ -6,5 +6,5 @@ LL |     type FooFuture<'a> = impl Trait1;
    |
    = note: `FooFuture` must be used in combination with a concrete type within the same impl
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/issue-87258_b.stderr b/tests/ui/generic-associated-types/issue-87258_b.stderr
index 0ee665f38ad..73f984dcfb8 100644
--- a/tests/ui/generic-associated-types/issue-87258_b.stderr
+++ b/tests/ui/generic-associated-types/issue-87258_b.stderr
@@ -6,5 +6,5 @@ LL | type Helper<'xenon, 'yttrium, KABOOM: Trait2> = impl Trait1;
    |
    = note: `Helper` must be used in combination with a concrete type within the same module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/issue-87429-associated-type-default.stderr b/tests/ui/generic-associated-types/issue-87429-associated-type-default.stderr
index a44bb6993d4..c85b72fbfe1 100644
--- a/tests/ui/generic-associated-types/issue-87429-associated-type-default.stderr
+++ b/tests/ui/generic-associated-types/issue-87429-associated-type-default.stderr
@@ -16,6 +16,6 @@ LL + #[derive(PartialEq)]
 LL | struct Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-87429-specialization.stderr b/tests/ui/generic-associated-types/issue-87429-specialization.stderr
index c259c89a712..44f871e71c5 100644
--- a/tests/ui/generic-associated-types/issue-87429-specialization.stderr
+++ b/tests/ui/generic-associated-types/issue-87429-specialization.stderr
@@ -26,6 +26,6 @@ LL + #[derive(PartialEq)]
 LL | struct Foo;
    |
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-88287.stderr b/tests/ui/generic-associated-types/issue-88287.stderr
index d77076a28fa..79ac6d0f10b 100644
--- a/tests/ui/generic-associated-types/issue-88287.stderr
+++ b/tests/ui/generic-associated-types/issue-88287.stderr
@@ -22,6 +22,6 @@ help: consider relaxing the implicit `Sized` restriction
 LL |     T: SearchableResource<Criteria> + ?Sized,
    |                                     ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/issue-88360.stderr b/tests/ui/generic-associated-types/issue-88360.stderr
index ad40ee18001..64cd55e684c 100644
--- a/tests/ui/generic-associated-types/issue-88360.stderr
+++ b/tests/ui/generic-associated-types/issue-88360.stderr
@@ -17,6 +17,6 @@ LL -         *self.test()
 LL +         self.test()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/generic-associated-types/issue-88595.stderr b/tests/ui/generic-associated-types/issue-88595.stderr
index 2b1a25acfa4..ab75a924006 100644
--- a/tests/ui/generic-associated-types/issue-88595.stderr
+++ b/tests/ui/generic-associated-types/issue-88595.stderr
@@ -10,5 +10,5 @@ note: for this opaque type
 LL |     type B<'b> = impl Clone;
    |                  ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/issue-90014-tait.stderr b/tests/ui/generic-associated-types/issue-90014-tait.stderr
index b86e2a204b0..e4bcc92bf6e 100644
--- a/tests/ui/generic-associated-types/issue-90014-tait.stderr
+++ b/tests/ui/generic-associated-types/issue-90014-tait.stderr
@@ -17,6 +17,6 @@ note: this item must have the opaque type in its signature in order to be able t
 LL |     fn make_fut<'a>(&'a self) -> Self::Fut<'a> {
    |        ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/generic-associated-types/issue-90014-tait2.stderr b/tests/ui/generic-associated-types/issue-90014-tait2.stderr
index d04788a919a..ed0b2085c88 100644
--- a/tests/ui/generic-associated-types/issue-90014-tait2.stderr
+++ b/tests/ui/generic-associated-types/issue-90014-tait2.stderr
@@ -1,5 +1,5 @@
 error[E0792]: expected generic lifetime parameter, found `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0792`.
diff --git a/tests/ui/generic-associated-types/issue-90014.stderr b/tests/ui/generic-associated-types/issue-90014.stderr
index 0d49398cac9..2bb9d0c7ba6 100644
--- a/tests/ui/generic-associated-types/issue-90014.stderr
+++ b/tests/ui/generic-associated-types/issue-90014.stderr
@@ -17,6 +17,6 @@ help: copy the `where` clause predicates from the trait
 LL |     type Fut<'a> = impl Future<Output = ()> where Self: 'a;
    |                                             ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0477`.
diff --git a/tests/ui/generic-associated-types/issue-91883.stderr b/tests/ui/generic-associated-types/issue-91883.stderr
index d5db962094c..ac636ebb648 100644
--- a/tests/ui/generic-associated-types/issue-91883.stderr
+++ b/tests/ui/generic-associated-types/issue-91883.stderr
@@ -22,6 +22,6 @@ help: copy the `where` clause predicates from the trait
 LL |     type Cursor<'tx> = CursorImpl<'tx> where 'db: 'tx, Self: 'tx;
    |                                        +++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0478`.
diff --git a/tests/ui/generic-associated-types/issue-92033.stderr b/tests/ui/generic-associated-types/issue-92033.stderr
index ddc420a7b4e..5dfd66d544a 100644
--- a/tests/ui/generic-associated-types/issue-92033.stderr
+++ b/tests/ui/generic-associated-types/issue-92033.stderr
@@ -17,6 +17,6 @@ help: copy the `where` clause predicates from the trait
 LL |     type TextureIter<'a> = std::option::IntoIter<&'a Texture> where Self: 'a;
    |                                                               ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0477`.
diff --git a/tests/ui/generic-associated-types/issue-92096.stderr b/tests/ui/generic-associated-types/issue-92096.stderr
index 91a06d5acde..b9a16cf184e 100644
--- a/tests/ui/generic-associated-types/issue-92096.stderr
+++ b/tests/ui/generic-associated-types/issue-92096.stderr
@@ -4,5 +4,5 @@ error: `C` does not live long enough
 LL |     async move { c.connect().await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/issue-95305.stderr b/tests/ui/generic-associated-types/issue-95305.stderr
index eb15cbc620a..752bb32926c 100644
--- a/tests/ui/generic-associated-types/issue-95305.stderr
+++ b/tests/ui/generic-associated-types/issue-95305.stderr
@@ -4,6 +4,6 @@ error[E0637]: `'_` cannot be used here
 LL | fn foo(x: &impl Foo<Item<'_> = u32>) { }
    |                          ^^ `'_` is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/generic-associated-types/method-unsatisfied-assoc-type-predicate.stderr b/tests/ui/generic-associated-types/method-unsatisfied-assoc-type-predicate.stderr
index 4246f8c069d..7ca0b2912a6 100644
--- a/tests/ui/generic-associated-types/method-unsatisfied-assoc-type-predicate.stderr
+++ b/tests/ui/generic-associated-types/method-unsatisfied-assoc-type-predicate.stderr
@@ -19,6 +19,6 @@ LL | impl<T: X<Y<i32> = i32>> M for T {}
    |           |
    |           unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/generic-associated-types/mismatched-where-clause-regions.stderr b/tests/ui/generic-associated-types/mismatched-where-clause-regions.stderr
index 91a03007640..ee90f61aabc 100644
--- a/tests/ui/generic-associated-types/mismatched-where-clause-regions.stderr
+++ b/tests/ui/generic-associated-types/mismatched-where-clause-regions.stderr
@@ -12,6 +12,6 @@ help: copy the `where` clause predicates from the trait
 LL |     type T<'a2, 'b2> = () where 'a2: 'b2;
    |                           ~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/generic-associated-types/missing-item-sugg.stderr b/tests/ui/generic-associated-types/missing-item-sugg.stderr
index 378115f6d38..1f142f7f6c1 100644
--- a/tests/ui/generic-associated-types/missing-item-sugg.stderr
+++ b/tests/ui/generic-associated-types/missing-item-sugg.stderr
@@ -6,6 +6,6 @@ LL | impl missing_item_sugg::Foo for Local {
    |
    = help: implement the missing item: `type Gat<T> = /* Type */ where T: std::fmt::Display;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/generic-associated-types/missing-where-clause-on-trait.stderr b/tests/ui/generic-associated-types/missing-where-clause-on-trait.stderr
index 8a71fc73a9d..d0eb27343a9 100644
--- a/tests/ui/generic-associated-types/missing-where-clause-on-trait.stderr
+++ b/tests/ui/generic-associated-types/missing-where-clause-on-trait.stderr
@@ -13,6 +13,6 @@ LL -     type Assoc<'a, 'b> = () where 'a: 'b;
 LL +     type Assoc<'a, 'b> = () ;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/generic-associated-types/missing_lifetime_const.stderr b/tests/ui/generic-associated-types/missing_lifetime_const.stderr
index 41945aabfb5..ac096086407 100644
--- a/tests/ui/generic-associated-types/missing_lifetime_const.stderr
+++ b/tests/ui/generic-associated-types/missing_lifetime_const.stderr
@@ -14,6 +14,6 @@ help: add missing lifetime argument
 LL |     let _: <T as Foo>::Assoc<'a, 3>;
    |                              +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generic-associated-types/multiple-type-params-with-unmet-bounds.stderr b/tests/ui/generic-associated-types/multiple-type-params-with-unmet-bounds.stderr
index 72a987b4a1d..57bff7c9e05 100644
--- a/tests/ui/generic-associated-types/multiple-type-params-with-unmet-bounds.stderr
+++ b/tests/ui/generic-associated-types/multiple-type-params-with-unmet-bounds.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Trait::P`
 LL |     type P<T: Copy, U: Copy>;
    |               ^^^^ required by this bound in `Trait::P`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/own-bound-span.stderr b/tests/ui/generic-associated-types/own-bound-span.stderr
index 4a0566ca7b5..7c34a0acdbe 100644
--- a/tests/ui/generic-associated-types/own-bound-span.stderr
+++ b/tests/ui/generic-associated-types/own-bound-span.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `D::P`
 LL |     type P<T: Copy>;
    |               ^^^^ required by this bound in `D::P`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/parse/trait-path-expected-token.stderr b/tests/ui/generic-associated-types/parse/trait-path-expected-token.stderr
index 53d5f9de657..59c21e24a42 100644
--- a/tests/ui/generic-associated-types/parse/trait-path-expected-token.stderr
+++ b/tests/ui/generic-associated-types/parse/trait-path-expected-token.stderr
@@ -6,5 +6,5 @@ LL | fn f1<'a>(arg : Box<dyn X<Y = B = &'a ()>>) {}
    |                               |
    |                               maybe try to close unmatched angle bracket
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/projection-bound-cycle-generic.stderr b/tests/ui/generic-associated-types/projection-bound-cycle-generic.stderr
index aae9a56bb61..1b3b264e750 100644
--- a/tests/ui/generic-associated-types/projection-bound-cycle-generic.stderr
+++ b/tests/ui/generic-associated-types/projection-bound-cycle-generic.stderr
@@ -4,6 +4,6 @@ error[E0275]: overflow evaluating the requirement `<Number<T> as Foo>::Item == _
 LL |     type Item = [T] where [T]: Sized;
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/generic-associated-types/projection-bound-cycle.stderr b/tests/ui/generic-associated-types/projection-bound-cycle.stderr
index b1b8afeecd0..6f5eee9928c 100644
--- a/tests/ui/generic-associated-types/projection-bound-cycle.stderr
+++ b/tests/ui/generic-associated-types/projection-bound-cycle.stderr
@@ -4,6 +4,6 @@ error[E0275]: overflow evaluating the requirement `<Number as Foo>::Item == _`
 LL |     type Item = str where str: Sized;
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/generic-associated-types/trait-objects.base.stderr b/tests/ui/generic-associated-types/trait-objects.base.stderr
index 556422c272c..e3cfd46524e 100644
--- a/tests/ui/generic-associated-types/trait-objects.base.stderr
+++ b/tests/ui/generic-associated-types/trait-objects.base.stderr
@@ -13,6 +13,6 @@ LL |     type Item<'a> where Self: 'a;
    |          ^^^^ ...because it contains the generic associated type `Item`
    = help: consider moving `Item` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/generic-associated-types/trait-objects.extended.stderr b/tests/ui/generic-associated-types/trait-objects.extended.stderr
index 45b64d2b024..9f9418e20b9 100644
--- a/tests/ui/generic-associated-types/trait-objects.extended.stderr
+++ b/tests/ui/generic-associated-types/trait-objects.extended.stderr
@@ -14,6 +14,6 @@ LL |     x.size_hint().0
    |
    = note: due to current limitations in the borrow checker, this implies a `'static` lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/generic-const-items/const-trait-impl.stderr b/tests/ui/generic-const-items/const-trait-impl.stderr
index 64aa8adf8a7..e7e90542796 100644
--- a/tests/ui/generic-const-items/const-trait-impl.stderr
+++ b/tests/ui/generic-const-items/const-trait-impl.stderr
@@ -6,6 +6,6 @@ LL | const CREATE<T: Create>: T = T::create();
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/generic-const-items/evaluatable-bounds.unconstrained.stderr b/tests/ui/generic-const-items/evaluatable-bounds.unconstrained.stderr
index 930080f7c37..1475d988ea4 100644
--- a/tests/ui/generic-const-items/evaluatable-bounds.unconstrained.stderr
+++ b/tests/ui/generic-const-items/evaluatable-bounds.unconstrained.stderr
@@ -6,5 +6,5 @@ LL |     const ARRAY: [i32; Self::LEN];
    |
    = help: try adding a `where` bound using this expression: `where [(); Self::LEN]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-const-items/parameter-defaults.stderr b/tests/ui/generic-const-items/parameter-defaults.stderr
index 62da45e55d6..59862286945 100644
--- a/tests/ui/generic-const-items/parameter-defaults.stderr
+++ b/tests/ui/generic-const-items/parameter-defaults.stderr
@@ -4,5 +4,5 @@ error: defaults for type parameters are only allowed in `struct`, `enum`, `type`
 LL | const NONE<T = ()>: Option<T> = None::<T>;
    |            ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-const-items/reference-outlives-referent.stderr b/tests/ui/generic-const-items/reference-outlives-referent.stderr
index 2b57713b5c1..34553c51654 100644
--- a/tests/ui/generic-const-items/reference-outlives-referent.stderr
+++ b/tests/ui/generic-const-items/reference-outlives-referent.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL | const Q<'a, 'b>: &'a &'b () = &&();
    |             ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.stderr b/tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.stderr
index c3ef94529a4..942e5dbd88e 100644
--- a/tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.stderr
+++ b/tests/ui/generic-const-items/trivially-unsatisfied-bounds-0.stderr
@@ -13,6 +13,6 @@ LL | where
 LL |     String: Copy;
    |             ^^^^ required by this bound in `UNUSABLE`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-const-items/trivially-unsatisfied-bounds-1.stderr b/tests/ui/generic-const-items/trivially-unsatisfied-bounds-1.stderr
index a68400798d8..b8438a0589c 100644
--- a/tests/ui/generic-const-items/trivially-unsatisfied-bounds-1.stderr
+++ b/tests/ui/generic-const-items/trivially-unsatisfied-bounds-1.stderr
@@ -6,6 +6,6 @@ LL | | where
 LL | |     String: Copy;
    | |_________________^ entering unreachable code
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/generic-const-items/unsatisfied-evaluatable-bounds.stderr b/tests/ui/generic-const-items/unsatisfied-evaluatable-bounds.stderr
index bed213b0caa..f522190e8aa 100644
--- a/tests/ui/generic-const-items/unsatisfied-evaluatable-bounds.stderr
+++ b/tests/ui/generic-const-items/unsatisfied-evaluatable-bounds.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of `POSITIVE::<0>::{constant#0}` failed
 LL |     [(); N - 1]:;
    |          ^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/generics/generic-extern.stderr b/tests/ui/generics/generic-extern.stderr
index c90215b612d..4d9f6fedef1 100644
--- a/tests/ui/generics/generic-extern.stderr
+++ b/tests/ui/generics/generic-extern.stderr
@@ -6,6 +6,6 @@ LL |     fn foo<T>();
    |
    = help: replace the type parameters with concrete types like `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0044`.
diff --git a/tests/ui/generics/generic-function-item-where-type.stderr b/tests/ui/generics/generic-function-item-where-type.stderr
index 88594129caa..00e62843cb4 100644
--- a/tests/ui/generics/generic-function-item-where-type.stderr
+++ b/tests/ui/generics/generic-function-item-where-type.stderr
@@ -7,6 +7,6 @@ LL |     foo::<main>()
    = help: `main` is a function item, not a type
    = help: function item types cannot be named directly
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/generics/generic-impl-less-params-with-defaults.stderr b/tests/ui/generics/generic-impl-less-params-with-defaults.stderr
index 262561fa81e..11227328e1b 100644
--- a/tests/ui/generics/generic-impl-less-params-with-defaults.stderr
+++ b/tests/ui/generics/generic-impl-less-params-with-defaults.stderr
@@ -16,6 +16,6 @@ help: add missing generic argument
 LL |     Foo::<isize, B>::new();
    |                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generics/generic-impl-more-params-with-defaults.stderr b/tests/ui/generics/generic-impl-more-params-with-defaults.stderr
index 2f4682c4e5a..c5812abfd3d 100644
--- a/tests/ui/generics/generic-impl-more-params-with-defaults.stderr
+++ b/tests/ui/generics/generic-impl-more-params-with-defaults.stderr
@@ -12,6 +12,6 @@ note: struct defined here, with at most 2 generic parameters: `T`, `A`
 LL | struct Vec<T, A = Heap>(
    |        ^^^ -  --------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generics/generic-lifetime-trait-impl.stderr b/tests/ui/generics/generic-lifetime-trait-impl.stderr
index 4ae5098a121..6974c8ad045 100644
--- a/tests/ui/generics/generic-lifetime-trait-impl.stderr
+++ b/tests/ui/generics/generic-lifetime-trait-impl.stderr
@@ -7,6 +7,6 @@ LL |     fn bar<'b, T: Bar<'b>>(self) -> &'b str;
 LL |     fn bar<T: Bar<'a>>(self) -> &'a str { panic!() }
    |           ^^^^^^^^^^^^ lifetimes do not match method in trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0195`.
diff --git a/tests/ui/generics/generic-type-less-params-with-defaults.stderr b/tests/ui/generics/generic-type-less-params-with-defaults.stderr
index 6450bbd8b43..6f79b09f6cd 100644
--- a/tests/ui/generics/generic-type-less-params-with-defaults.stderr
+++ b/tests/ui/generics/generic-type-less-params-with-defaults.stderr
@@ -14,6 +14,6 @@ help: add missing generic argument
 LL |     let _: Vec<T>;
    |               +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generics/generic-type-more-params-with-defaults.stderr b/tests/ui/generics/generic-type-more-params-with-defaults.stderr
index 4d01ba1f453..c44f6b7ddc0 100644
--- a/tests/ui/generics/generic-type-more-params-with-defaults.stderr
+++ b/tests/ui/generics/generic-type-more-params-with-defaults.stderr
@@ -12,6 +12,6 @@ note: struct defined here, with at most 2 generic parameters: `T`, `A`
 LL | struct Vec<T, A = Heap>(
    |        ^^^ -  --------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/generics/generic-type-params-forward-mention.stderr b/tests/ui/generics/generic-type-params-forward-mention.stderr
index fa661c274eb..d7a6faa1941 100644
--- a/tests/ui/generics/generic-type-params-forward-mention.stderr
+++ b/tests/ui/generics/generic-type-params-forward-mention.stderr
@@ -4,6 +4,6 @@ error[E0128]: generic parameters with a default cannot use forward declared iden
 LL | struct Foo<T = Option<U>, U = bool>(T, U);
    |                       ^ defaulted generic parameters cannot be forward declared
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0128`.
diff --git a/tests/ui/generics/issue-59508-1.stderr b/tests/ui/generics/issue-59508-1.stderr
index 1c510044f80..7d4fdb2d879 100644
--- a/tests/ui/generics/issue-59508-1.stderr
+++ b/tests/ui/generics/issue-59508-1.stderr
@@ -4,5 +4,5 @@ error: lifetime parameters must be declared prior to type and const parameters
 LL |     pub fn do_things<T, 'a, 'b: 'a>() {
    |                     ----^^--^^----- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b: 'a, T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/issue-59508.stderr b/tests/ui/generics/issue-59508.stderr
index fd23b6276f9..aeaf0187eb5 100644
--- a/tests/ui/generics/issue-59508.stderr
+++ b/tests/ui/generics/issue-59508.stderr
@@ -4,5 +4,5 @@ error: lifetime parameters must be declared prior to type and const parameters
 LL |     pub fn do_things<T, 'a, 'b: 'a>() {
    |                     ----^^--^^----- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b: 'a, T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/issue-61631-default-type-param-can-reference-self-in-trait.stderr b/tests/ui/generics/issue-61631-default-type-param-can-reference-self-in-trait.stderr
index 6791182238c..3f4f50562e2 100644
--- a/tests/ui/generics/issue-61631-default-type-param-can-reference-self-in-trait.stderr
+++ b/tests/ui/generics/issue-61631-default-type-param-can-reference-self-in-trait.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `Tsized`
 LL | trait Tsized<P: Sized = [Self]> {}
    |              ^^^^^^^^^^^^^^^^^ required by this bound in `Tsized`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generics/issue-79605.stderr b/tests/ui/generics/issue-79605.stderr
index c5584962dc9..67fed200f96 100644
--- a/tests/ui/generics/issue-79605.stderr
+++ b/tests/ui/generics/issue-79605.stderr
@@ -9,6 +9,6 @@ help: use type parameters instead
 LL | impl<T> X<'_, T> {}
    |     +++       ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/generics/issue-80512-param-reordering-with-defaults.stderr b/tests/ui/generics/issue-80512-param-reordering-with-defaults.stderr
index 70793a9c920..d7e12f07e06 100644
--- a/tests/ui/generics/issue-80512-param-reordering-with-defaults.stderr
+++ b/tests/ui/generics/issue-80512-param-reordering-with-defaults.stderr
@@ -4,5 +4,5 @@ error: lifetime parameters must be declared prior to type and const parameters
 LL | struct S<T = (), 'a>(&'a T);
    |         ---------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, T = ()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/issue-83556.stderr b/tests/ui/generics/issue-83556.stderr
index 93affaffe60..0c5a65f0c3d 100644
--- a/tests/ui/generics/issue-83556.stderr
+++ b/tests/ui/generics/issue-83556.stderr
@@ -4,5 +4,5 @@ error: lifetime parameters must be declared prior to type and const parameters
 LL | struct Foo<T, 'a>(&'a ());
    |           ----^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/issue-95208-ignore-qself.stderr b/tests/ui/generics/issue-95208-ignore-qself.stderr
index acbc1300d00..cf40e857d42 100644
--- a/tests/ui/generics/issue-95208-ignore-qself.stderr
+++ b/tests/ui/generics/issue-95208-ignore-qself.stderr
@@ -6,5 +6,5 @@ LL | impl<T: Iterator> Struct<T> where <T as std:: iter::Iterator>::Item:: std::
    |                                                                    |
    |                                                                    help: use single colon: `:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/issue-95208.stderr b/tests/ui/generics/issue-95208.stderr
index 559527663e8..0d856d096af 100644
--- a/tests/ui/generics/issue-95208.stderr
+++ b/tests/ui/generics/issue-95208.stderr
@@ -6,5 +6,5 @@ LL | impl<T> Struct<T> where T:: std::fmt::Display {
    |                          |
    |                          help: use single colon: `:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/issue-98432.stderr b/tests/ui/generics/issue-98432.stderr
index 0736d94106e..2b09d43960f 100644
--- a/tests/ui/generics/issue-98432.stderr
+++ b/tests/ui/generics/issue-98432.stderr
@@ -9,6 +9,6 @@ LL |         struct _Obligation where T:;
    |                           |
    |                           help: try introducing a local generic parameter here: `<T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/generics/param-in-ct-in-ty-param-default.stderr b/tests/ui/generics/param-in-ct-in-ty-param-default.stderr
index ab09ebcae71..3d2a26e33c3 100644
--- a/tests/ui/generics/param-in-ct-in-ty-param-default.stderr
+++ b/tests/ui/generics/param-in-ct-in-ty-param-default.stderr
@@ -7,5 +7,5 @@ LL | struct Foo<T, U = [u8; std::mem::size_of::<T>()]>(T, U);
    = note: type parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/single-colon-path-not-const-generics.stderr b/tests/ui/generics/single-colon-path-not-const-generics.stderr
index 96f07e190c1..d61562bb199 100644
--- a/tests/ui/generics/single-colon-path-not-const-generics.stderr
+++ b/tests/ui/generics/single-colon-path-not-const-generics.stderr
@@ -8,5 +8,5 @@ LL |   a: Vec<foo::bar:A>,
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/slightly-nice-generic-literal-messages.stderr b/tests/ui/generics/slightly-nice-generic-literal-messages.stderr
index 83ef522ab46..9811d30cf6a 100644
--- a/tests/ui/generics/slightly-nice-generic-literal-messages.stderr
+++ b/tests/ui/generics/slightly-nice-generic-literal-messages.stderr
@@ -9,6 +9,6 @@ LL |         1 => {}
    = note: expected struct `Foo<{float}, _>`
                 found type `{integer}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/half-open-range-patterns/exclusive_range_pattern_syntax_collision.stderr b/tests/ui/half-open-range-patterns/exclusive_range_pattern_syntax_collision.stderr
index 6ce56ba4b7c..357d3a4a124 100644
--- a/tests/ui/half-open-range-patterns/exclusive_range_pattern_syntax_collision.stderr
+++ b/tests/ui/half-open-range-patterns/exclusive_range_pattern_syntax_collision.stderr
@@ -9,6 +9,6 @@ LL |         [_, 99.., _] => {},
    = note: expected struct `std::ops::Range<{integer}>`
                 found type `{integer}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/half-open-range-patterns/feature-gate-half-open-range-patterns-in-slices.stderr b/tests/ui/half-open-range-patterns/feature-gate-half-open-range-patterns-in-slices.stderr
index ee5b0e11c66..b44a69525a6 100644
--- a/tests/ui/half-open-range-patterns/feature-gate-half-open-range-patterns-in-slices.stderr
+++ b/tests/ui/half-open-range-patterns/feature-gate-half-open-range-patterns-in-slices.stderr
@@ -7,6 +7,6 @@ LL |     let [a @ 3.., b @ ..3, c @ 4..6, ..] = xs;
    = note: see issue #67264 <https://github.com/rust-lang/rust/issues/67264> for more information
    = help: add `#![feature(half_open_range_patterns_in_slices)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/half-open-range-patterns/half-open-range-pats-inclusive-match-arrow.stderr b/tests/ui/half-open-range-patterns/half-open-range-pats-inclusive-match-arrow.stderr
index cb7f998df7a..8dfc46069f1 100644
--- a/tests/ui/half-open-range-patterns/half-open-range-pats-inclusive-match-arrow.stderr
+++ b/tests/ui/half-open-range-patterns/half-open-range-pats-inclusive-match-arrow.stderr
@@ -11,5 +11,5 @@ help: add a space between the pattern and `=>`
 LL |         74.. => {},
    |             +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/half-open-range-patterns/pat-tuple-5.stderr b/tests/ui/half-open-range-patterns/pat-tuple-5.stderr
index 43e7f03b8b4..a7dd4139792 100644
--- a/tests/ui/half-open-range-patterns/pat-tuple-5.stderr
+++ b/tests/ui/half-open-range-patterns/pat-tuple-5.stderr
@@ -9,6 +9,6 @@ LL |         (PAT ..) => {}
    = note: expected tuple `({integer}, {integer})`
                found type `u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/half-open-range-patterns/slice_pattern_syntax_problem0.stderr b/tests/ui/half-open-range-patterns/slice_pattern_syntax_problem0.stderr
index ec3472a5036..eca5c330180 100644
--- a/tests/ui/half-open-range-patterns/slice_pattern_syntax_problem0.stderr
+++ b/tests/ui/half-open-range-patterns/slice_pattern_syntax_problem0.stderr
@@ -4,6 +4,6 @@ error[E0527]: pattern requires 2 elements but array has 8
 LL |     let [first_three @ ..3, rest @ 2..] = xs;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 8 elements
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0527`.
diff --git a/tests/ui/hashmap/hashmap-index-mut.stderr b/tests/ui/hashmap/hashmap-index-mut.stderr
index c1948ab6271..2381b8ecb96 100644
--- a/tests/ui/hashmap/hashmap-index-mut.stderr
+++ b/tests/ui/hashmap/hashmap-index-mut.stderr
@@ -14,6 +14,6 @@ LL |     map.get_mut(&0).map(|val| { *val = 1; });
 LL |     let val = map.entry(&0).or_insert(1);
    |     +++++++++    ~~~~~~~  ~~~~~~~~~~~~ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/hashmap/hashmap-iter-value-lifetime.stderr b/tests/ui/hashmap/hashmap-iter-value-lifetime.stderr
index de2591329c8..5cf188702da 100644
--- a/tests/ui/hashmap/hashmap-iter-value-lifetime.stderr
+++ b/tests/ui/hashmap/hashmap-iter-value-lifetime.stderr
@@ -10,6 +10,6 @@ LL |
 LL |     println!("{}", *thing);
    |                    ------ immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/hashmap/hashmap-lifetimes.stderr b/tests/ui/hashmap/hashmap-lifetimes.stderr
index 497c7d1216c..a52f956d063 100644
--- a/tests/ui/hashmap/hashmap-lifetimes.stderr
+++ b/tests/ui/hashmap/hashmap-lifetimes.stderr
@@ -8,6 +8,6 @@ LL |     my_stuff.insert(1, 43);
 LL |     it;
    |     -- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/higher-ranked/higher-ranked-lifetime-error.stderr b/tests/ui/higher-ranked/higher-ranked-lifetime-error.stderr
index 890dac16e94..d0892fd8b09 100644
--- a/tests/ui/higher-ranked/higher-ranked-lifetime-error.stderr
+++ b/tests/ui/higher-ranked/higher-ranked-lifetime-error.stderr
@@ -7,6 +7,6 @@ LL |     assert_all::<_, &String>(id);
    = note: expected reference `&String`
               found reference `&String`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_b_ret_a_vs_bound_a_ret_a.stderr b/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_b_ret_a_vs_bound_a_ret_a.stderr
index b7264c7e933..7cb7edfafeb 100644
--- a/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_b_ret_a_vs_bound_a_ret_a.stderr
+++ b/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_b_ret_a_vs_bound_a_ret_a.stderr
@@ -12,6 +12,6 @@ LL | | for<'a>    fn(&'a u32, &'a u32) -> &'a u32) }
               found enum `Option<for<'a> fn(&'a u32, &'a u32) -> &'a u32>`
    = note: this error originates in the macro `check` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_vs_free_x.stderr b/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_vs_free_x.stderr
index 2355979b0f9..c6adbd91e78 100644
--- a/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_vs_free_x.stderr
+++ b/tests/ui/higher-ranked/subtype/hr-subtype.bound_a_vs_free_x.stderr
@@ -12,6 +12,6 @@ LL | | fn(&'x u32)) }
               found enum `Option<fn(&u32)>`
    = note: this error originates in the macro `check` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/higher-ranked/subtype/hr-subtype.free_x_vs_free_y.stderr b/tests/ui/higher-ranked/subtype/hr-subtype.free_x_vs_free_y.stderr
index 269cde54c7e..a8e00125fc6 100644
--- a/tests/ui/higher-ranked/subtype/hr-subtype.free_x_vs_free_y.stderr
+++ b/tests/ui/higher-ranked/subtype/hr-subtype.free_x_vs_free_y.stderr
@@ -15,5 +15,5 @@ LL | | fn(&'y u32)) }
    = help: consider adding the following bound: `'x: 'y`
    = note: this error originates in the macro `check` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/subtype/placeholder-pattern-fail.stderr b/tests/ui/higher-ranked/subtype/placeholder-pattern-fail.stderr
index 5241b475d5c..c6d6f508328 100644
--- a/tests/ui/higher-ranked/subtype/placeholder-pattern-fail.stderr
+++ b/tests/ui/higher-ranked/subtype/placeholder-pattern-fail.stderr
@@ -9,6 +9,6 @@ LL |     let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
    = note: expected fn pointer `for<'a, 'b> fn(Inv<'a>, Inv<'b>)`
               found fn pointer `for<'a> fn(Inv<'a>, Inv<'a>)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/higher-ranked/trait-bounds/due-to-where-clause.stderr b/tests/ui/higher-ranked/trait-bounds/due-to-where-clause.stderr
index 520938a6335..916854e07af 100644
--- a/tests/ui/higher-ranked/trait-bounds/due-to-where-clause.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/due-to-where-clause.stderr
@@ -7,5 +7,5 @@ LL |     test::<FooS>(&mut 42);
    = note: `FooS<'_>` must implement `Foo<'0>`, for any lifetime `'0`...
    = note: ...but `FooS<'_>` actually implements `Foo<'1>`, for some specific lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/trait-bounds/fn-ptr.classic.stderr b/tests/ui/higher-ranked/trait-bounds/fn-ptr.classic.stderr
index 8ab88c58075..77aa37cefe3 100644
--- a/tests/ui/higher-ranked/trait-bounds/fn-ptr.classic.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/fn-ptr.classic.stderr
@@ -14,6 +14,6 @@ LL | where
 LL |     for<'w> fn(&'w ()): Fn(&'w ()),
    |                         ^^^^^^^^^^ required by this bound in `ice`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.stderr b/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.stderr
index 139c844d8a2..67417a5e525 100644
--- a/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hang-on-deeply-nested-dyn.stderr
@@ -16,6 +16,6 @@ LL |       f
    = note: expected reference `&dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn Fn(u32) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a))`
               found reference `&dyn Fn(u32)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-cache-issue-54302.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-cache-issue-54302.stderr
index f014eab8601..7f81ee331bf 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-cache-issue-54302.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-cache-issue-54302.stderr
@@ -7,5 +7,5 @@ LL |     assert_deserialize_owned::<&'static str>();
    = note: `&'static str` must implement `Deserialize<'0>`, for any lifetime `'0`...
    = note: ...but `&str` actually implements `Deserialize<'1>`, for some specific lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-debruijn-in-receiver.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-debruijn-in-receiver.stderr
index 70d5b3c2ec5..10904515fd8 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-debruijn-in-receiver.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-debruijn-in-receiver.stderr
@@ -9,6 +9,6 @@ LL |     foo.insert();
    |     second mutable borrow occurs here
    |     first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-fn.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-fn.stderr
index db5fc4bf1ba..f269babcf71 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-fn.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-fn.stderr
@@ -9,6 +9,6 @@ LL |     let _: for<'b> fn(&'b u32) = foo();
    = note: expected fn pointer `for<'b> fn(&'b u32)`
               found fn pointer `fn(&u32)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-contravariant.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-contravariant.stderr
index 364b613fc77..9697a270b8a 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-contravariant.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-contravariant.stderr
@@ -7,5 +7,5 @@ LL |     foo::<()>();
    = note: `()` must implement `Trait<for<'b> fn(&'b u32)>`
    = note: ...but it actually implements `Trait<fn(&'0 u32)>`, for some specific lifetime `'0`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-invariant.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-invariant.stderr
index cb2ce8a4116..cf64c2acdbe 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-invariant.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-exists-forall-trait-invariant.stderr
@@ -7,5 +7,5 @@ LL |     foo::<()>();
    = note: `()` must implement `Trait<for<'b> fn(Cell<&'b u32>)>`
    = note: ...but it actually implements `Trait<fn(Cell<&'0 u32>)>`, for some specific lifetime `'0`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
index b1b8ffa8c54..e10da26665e 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr
@@ -18,6 +18,6 @@ help: consider further restricting this bound
 LL |     where B : Qux + for<'ccx> Bar<'ccx>
    |                   +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-identity-fn-borrows.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-identity-fn-borrows.stderr
index 25af011e3fc..b1081c073ef 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-identity-fn-borrows.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-identity-fn-borrows.stderr
@@ -9,6 +9,6 @@ LL |     x = 5;
 LL |     drop(y);
    |          - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/higher-ranked/trait-bounds/issue-46989.stderr b/tests/ui/higher-ranked/trait-bounds/issue-46989.stderr
index 3f874220a27..c50e79dd4cc 100644
--- a/tests/ui/higher-ranked/trait-bounds/issue-46989.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/issue-46989.stderr
@@ -7,5 +7,5 @@ LL |     assert_foo::<fn(&i32)>();
    = note: `Foo` would have to be implemented for the type `for<'a> fn(&'a i32)`
    = note: ...but `Foo` is actually implemented for the type `fn(&'0 i32)`, for some specific lifetime `'0`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/trait-bounds/issue-58451.stderr b/tests/ui/higher-ranked/trait-bounds/issue-58451.stderr
index 0f051be2128..99d088799fb 100644
--- a/tests/ui/higher-ranked/trait-bounds/issue-58451.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/issue-58451.stderr
@@ -14,6 +14,6 @@ help: provide the argument
 LL |     f(&[f(/* i */)]);
    |          ~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/higher-ranked/trait-bounds/issue-95230.next.stderr b/tests/ui/higher-ranked/trait-bounds/issue-95230.next.stderr
index d4bc5b67220..6155579c9fa 100644
--- a/tests/ui/higher-ranked/trait-bounds/issue-95230.next.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/issue-95230.next.stderr
@@ -14,6 +14,6 @@ LL | where
 LL |     for<'a> &'a mut Self:;
    |             ^^^^^^^^^^^^ required by this bound in `Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-3.stderr b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-3.stderr
index 7b0743cc7c5..64707642eeb 100644
--- a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-3.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-62529-3.stderr
@@ -22,6 +22,6 @@ note: required by a bound in `call`
 LL | fn call<'b, T: for<'a> ATC<'a>, F: for<'a> Fn(<T as ATC<'a>>::Type)>(
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `call`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90950.stderr b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90950.stderr
index 55eaef78634..075e422e29c 100644
--- a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90950.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/issue-90950.stderr
@@ -24,6 +24,6 @@ LL |     Y: for<'a> Yokeable<'a>,
 LL |     for<'a> <Y as Yokeable<'a>>::Output: IsCovariant<'a>
    |                                          ^^^^^^^^^^^^^^^ required by this bound in `upcast`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr
index 081dbb67df8..a2ec96f1a2d 100644
--- a/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr
@@ -18,6 +18,6 @@ LL | fn weird_bound<X>() -> X
 LL |         for<'a> <X as Trait<'a>>::Out: Copy
    |                                        ^^^^ required by this bound in `weird_bound`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/hygiene/arguments.stderr b/tests/ui/hygiene/arguments.stderr
index 714178375f2..0d8d652b6f3 100644
--- a/tests/ui/hygiene/arguments.stderr
+++ b/tests/ui/hygiene/arguments.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `S` in this scope
 LL |     m!(S, S);
    |        ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/hygiene/cross-crate-glob-hygiene.stderr b/tests/ui/hygiene/cross-crate-glob-hygiene.stderr
index 7369e77d070..1abc739fc36 100644
--- a/tests/ui/hygiene/cross-crate-glob-hygiene.stderr
+++ b/tests/ui/hygiene/cross-crate-glob-hygiene.stderr
@@ -6,6 +6,6 @@ LL |     let x = my_struct!(create);
    |
    = note: this error originates in the macro `my_struct` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/hygiene/cross-crate-name-hiding-2.stderr b/tests/ui/hygiene/cross-crate-name-hiding-2.stderr
index 46314cdd5ab..a5d509fab99 100644
--- a/tests/ui/hygiene/cross-crate-name-hiding-2.stderr
+++ b/tests/ui/hygiene/cross-crate-name-hiding-2.stderr
@@ -4,6 +4,6 @@ error[E0422]: cannot find struct, variant or union type `MyStruct` in this scope
 LL |     let x = MyStruct {};
    |             ^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/hygiene/cross-crate-name-hiding.stderr b/tests/ui/hygiene/cross-crate-name-hiding.stderr
index f8840c8f85a..4abd14f9355 100644
--- a/tests/ui/hygiene/cross-crate-name-hiding.stderr
+++ b/tests/ui/hygiene/cross-crate-name-hiding.stderr
@@ -4,6 +4,6 @@ error[E0422]: cannot find struct, variant or union type `MyStruct` in this scope
 LL |     let x = MyStruct {};
    |             ^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/hygiene/cross-crate-redefine.stderr b/tests/ui/hygiene/cross-crate-redefine.stderr
index 4f1419de426..c0fd3f4b7eb 100644
--- a/tests/ui/hygiene/cross-crate-redefine.stderr
+++ b/tests/ui/hygiene/cross-crate-redefine.stderr
@@ -10,6 +10,6 @@ LL | my_struct!(define);
    = note: `MyStruct` must be defined only once in the type namespace of this module
    = note: this error originates in the macro `my_struct` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/hygiene/expansion-info-reset.stderr b/tests/ui/hygiene/expansion-info-reset.stderr
index 64d27e06487..a3ae5042f0b 100644
--- a/tests/ui/hygiene/expansion-info-reset.stderr
+++ b/tests/ui/hygiene/expansion-info-reset.stderr
@@ -9,5 +9,5 @@ help: you might be missing a string literal to format with
 LL |     format_args!("{}", { #[derive(Clone)] struct S; });
    |                  +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/hygiene/fields-definition.stderr b/tests/ui/hygiene/fields-definition.stderr
index 9d091cedd23..701986ea76e 100644
--- a/tests/ui/hygiene/fields-definition.stderr
+++ b/tests/ui/hygiene/fields-definition.stderr
@@ -11,6 +11,6 @@ LL | legacy!(a);
    |
    = note: this error originates in the macro `legacy` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0124`.
diff --git a/tests/ui/hygiene/fields-numeric-borrowck.stderr b/tests/ui/hygiene/fields-numeric-borrowck.stderr
index fb90825c0d9..a2dd83d560f 100644
--- a/tests/ui/hygiene/fields-numeric-borrowck.stderr
+++ b/tests/ui/hygiene/fields-numeric-borrowck.stderr
@@ -9,6 +9,6 @@ LL |     let S { 0: ref mut borrow2 } = s;
 LL |     borrow1.use_mut();
    |     ------- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/hygiene/for-loop.stderr b/tests/ui/hygiene/for-loop.stderr
index 932c951e7a5..5f334fd8960 100644
--- a/tests/ui/hygiene/for-loop.stderr
+++ b/tests/ui/hygiene/for-loop.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `iter` in this scope
 LL |         iter.next();
    |         ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/hygiene/hygienic-label-1.stderr b/tests/ui/hygiene/hygienic-label-1.stderr
index deb6a205994..5529d8dc836 100644
--- a/tests/ui/hygiene/hygienic-label-1.stderr
+++ b/tests/ui/hygiene/hygienic-label-1.stderr
@@ -9,6 +9,6 @@ LL |     'x: loop { foo!(); }
    |
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0426`.
diff --git a/tests/ui/hygiene/hygienic-label-2.stderr b/tests/ui/hygiene/hygienic-label-2.stderr
index f23e741debe..77a77c8472f 100644
--- a/tests/ui/hygiene/hygienic-label-2.stderr
+++ b/tests/ui/hygiene/hygienic-label-2.stderr
@@ -4,6 +4,6 @@ error[E0426]: use of undeclared label `'x`
 LL |     foo!(break 'x);
    |                ^^ undeclared label `'x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0426`.
diff --git a/tests/ui/hygiene/hygienic-label-3.stderr b/tests/ui/hygiene/hygienic-label-3.stderr
index cf7f78a99e8..495afc69a95 100644
--- a/tests/ui/hygiene/hygienic-label-3.stderr
+++ b/tests/ui/hygiene/hygienic-label-3.stderr
@@ -9,6 +9,6 @@ LL |         foo!();
    |
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0426`.
diff --git a/tests/ui/hygiene/hygienic-label-4.stderr b/tests/ui/hygiene/hygienic-label-4.stderr
index 1c93da02f61..b9f447e1512 100644
--- a/tests/ui/hygiene/hygienic-label-4.stderr
+++ b/tests/ui/hygiene/hygienic-label-4.stderr
@@ -4,6 +4,6 @@ error[E0426]: use of undeclared label `'x`
 LL |     foo!(break 'x);
    |                ^^ undeclared label `'x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0426`.
diff --git a/tests/ui/hygiene/impl_items-2.stderr b/tests/ui/hygiene/impl_items-2.stderr
index 3c0ffeb1057..e7128f83e11 100644
--- a/tests/ui/hygiene/impl_items-2.stderr
+++ b/tests/ui/hygiene/impl_items-2.stderr
@@ -10,6 +10,6 @@ LL |     fn foo() {}
 LL |     fn foo() {}
    |     ^^^^^^^^^^^ duplicate definition
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0201`.
diff --git a/tests/ui/hygiene/impl_items.stderr b/tests/ui/hygiene/impl_items.stderr
index 32ba3741a59..35f2750403d 100644
--- a/tests/ui/hygiene/impl_items.stderr
+++ b/tests/ui/hygiene/impl_items.stderr
@@ -9,5 +9,5 @@ LL |     foo::m!();
    |
    = note: this error originates in the macro `foo::m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/hygiene/intercrate.stderr b/tests/ui/hygiene/intercrate.stderr
index f108617fba6..230ad052db3 100644
--- a/tests/ui/hygiene/intercrate.stderr
+++ b/tests/ui/hygiene/intercrate.stderr
@@ -6,5 +6,5 @@ LL |     assert_eq!(intercrate::foo::m!(), 1);
    |
    = note: this error originates in the macro `intercrate::foo::m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/hygiene/missing-self-diag.stderr b/tests/ui/hygiene/missing-self-diag.stderr
index 690bcd03226..6921ed29e20 100644
--- a/tests/ui/hygiene/missing-self-diag.stderr
+++ b/tests/ui/hygiene/missing-self-diag.stderr
@@ -12,6 +12,6 @@ LL | |     }
    |
    = note: this error originates in the macro `call_bar` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0424`.
diff --git a/tests/ui/hygiene/nested_macro_privacy.stderr b/tests/ui/hygiene/nested_macro_privacy.stderr
index 1d11cd0f571..44d11cfbafa 100644
--- a/tests/ui/hygiene/nested_macro_privacy.stderr
+++ b/tests/ui/hygiene/nested_macro_privacy.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `i` of struct `S` is private
 LL |     S::default().i;
    |                  ^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/hygiene/no_implicit_prelude-2018.stderr b/tests/ui/hygiene/no_implicit_prelude-2018.stderr
index b22f3e75b6f..7b124edf6f6 100644
--- a/tests/ui/hygiene/no_implicit_prelude-2018.stderr
+++ b/tests/ui/hygiene/no_implicit_prelude-2018.stderr
@@ -9,5 +9,5 @@ help: consider importing this macro
 LL +     use std::print;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/hygiene/pattern-macro.stderr b/tests/ui/hygiene/pattern-macro.stderr
index edd05916ede..a9764cea49e 100644
--- a/tests/ui/hygiene/pattern-macro.stderr
+++ b/tests/ui/hygiene/pattern-macro.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `x` in this scope
 LL |     x + 1;
    |     ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/hygiene/privacy-early.stderr b/tests/ui/hygiene/privacy-early.stderr
index 0375ed56d96..1c2f9ff5405 100644
--- a/tests/ui/hygiene/privacy-early.stderr
+++ b/tests/ui/hygiene/privacy-early.stderr
@@ -17,6 +17,6 @@ LL |     foo::m!();
    |     --------- in this macro invocation
    = note: this error originates in the macro `foo::m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0364`.
diff --git a/tests/ui/hygiene/privacy.stderr b/tests/ui/hygiene/privacy.stderr
index 70a24304dda..c677c881288 100644
--- a/tests/ui/hygiene/privacy.stderr
+++ b/tests/ui/hygiene/privacy.stderr
@@ -10,6 +10,6 @@ note: the function `f` is defined here
 LL |     fn f() {}
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/hygiene/trait_items.stderr b/tests/ui/hygiene/trait_items.stderr
index f303534c709..016ee8f71f9 100644
--- a/tests/ui/hygiene/trait_items.stderr
+++ b/tests/ui/hygiene/trait_items.stderr
@@ -17,6 +17,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL +     use foo::T;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/illegal-sized-bound/mutability-mismatch-arg.stderr b/tests/ui/illegal-sized-bound/mutability-mismatch-arg.stderr
index 89613bd5c20..b5ca62f4e23 100644
--- a/tests/ui/illegal-sized-bound/mutability-mismatch-arg.stderr
+++ b/tests/ui/illegal-sized-bound/mutability-mismatch-arg.stderr
@@ -9,5 +9,5 @@ help: you need `&mut dyn Iterator<Item = &u64>` instead of `&dyn Iterator<Item =
 LL | fn test(t: &mut dyn Iterator<Item=&u64>) -> u64 {
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/illegal-ufcs-drop.stderr b/tests/ui/illegal-ufcs-drop.stderr
index 7a5c0612c07..4f214a12747 100644
--- a/tests/ui/illegal-ufcs-drop.stderr
+++ b/tests/ui/illegal-ufcs-drop.stderr
@@ -7,6 +7,6 @@ LL |     Drop::drop(&mut Foo)
    |     explicit destructor calls not allowed
    |     help: consider using `drop` function: `drop`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0040`.
diff --git a/tests/ui/impl-header-lifetime-elision/dyn-trait.stderr b/tests/ui/impl-header-lifetime-elision/dyn-trait.stderr
index 762698c4fc1..2ef35a377e2 100644
--- a/tests/ui/impl-header-lifetime-elision/dyn-trait.stderr
+++ b/tests/ui/impl-header-lifetime-elision/dyn-trait.stderr
@@ -11,6 +11,6 @@ LL |     static_val(x);
    |     `x` escapes the function body here
    |     argument requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/impl-header-lifetime-elision/path-elided.stderr b/tests/ui/impl-header-lifetime-elision/path-elided.stderr
index 18e4c618dba..4df7ffb29ba 100644
--- a/tests/ui/impl-header-lifetime-elision/path-elided.stderr
+++ b/tests/ui/impl-header-lifetime-elision/path-elided.stderr
@@ -9,6 +9,6 @@ help: indicate the anonymous lifetime
 LL | impl MyTrait for Foo<'_> {
    |                     ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0726`.
diff --git a/tests/ui/impl-header-lifetime-elision/trait-elided.stderr b/tests/ui/impl-header-lifetime-elision/trait-elided.stderr
index 74631a03786..cbc6eee5a3f 100644
--- a/tests/ui/impl-header-lifetime-elision/trait-elided.stderr
+++ b/tests/ui/impl-header-lifetime-elision/trait-elided.stderr
@@ -9,6 +9,6 @@ help: indicate the anonymous lifetime
 LL | impl MyTrait<'_> for u32 {}
    |             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0726`.
diff --git a/tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.stderr b/tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.stderr
index 168a5aa18ec..825682c52f9 100644
--- a/tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.stderr
+++ b/tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.stderr
@@ -13,6 +13,6 @@ help: to declare that `impl Sized + 'a` captures `'b`, you can add an explicit `
 LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a + 'b {
    |                                           ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.stderr b/tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.stderr
index cabba4bafaf..b87e31acc12 100644
--- a/tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.stderr
+++ b/tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.stderr
@@ -13,6 +13,6 @@ help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'
 LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
    |                                                                          ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/alias-liveness/tait-hidden-erased-unsoundness.stderr b/tests/ui/impl-trait/alias-liveness/tait-hidden-erased-unsoundness.stderr
index baeec6d5892..6c9b8cf2427 100644
--- a/tests/ui/impl-trait/alias-liveness/tait-hidden-erased-unsoundness.stderr
+++ b/tests/ui/impl-trait/alias-liveness/tait-hidden-erased-unsoundness.stderr
@@ -8,6 +8,6 @@ LL |     pub(super) fn step2<'a, 'b: 'a>() -> Tait<'a> {
 LL |         super::step1::<'a, 'b>()
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr b/tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr
index d5086c7bc51..158cfc8347c 100644
--- a/tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr
+++ b/tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr
@@ -17,6 +17,6 @@ LL |       let () = y;
    = note: expected type parameter `impl FnOnce(&mut Header, &mut [EntryMetadata], &mut [Entry<C::EncodedKey, C::EncodedValue>]) -> R`
                    found unit type `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/auto-trait-coherence.next.stderr b/tests/ui/impl-trait/auto-trait-coherence.next.stderr
index 7833ac688ba..3f979d1a50b 100644
--- a/tests/ui/impl-trait/auto-trait-coherence.next.stderr
+++ b/tests/ui/impl-trait/auto-trait-coherence.next.stderr
@@ -7,6 +7,6 @@ LL | impl<T: Send> AnotherTrait for T {}
 LL | impl AnotherTrait for D<OpaqueType> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `D<OpaqueType>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/impl-trait/auto-trait-coherence.old.stderr b/tests/ui/impl-trait/auto-trait-coherence.old.stderr
index 7833ac688ba..3f979d1a50b 100644
--- a/tests/ui/impl-trait/auto-trait-coherence.old.stderr
+++ b/tests/ui/impl-trait/auto-trait-coherence.old.stderr
@@ -7,6 +7,6 @@ LL | impl<T: Send> AnotherTrait for T {}
 LL | impl AnotherTrait for D<OpaqueType> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `D<OpaqueType>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/impl-trait/auto-trait-leak.stderr b/tests/ui/impl-trait/auto-trait-leak.stderr
index 28643ec03e1..3fab766fa23 100644
--- a/tests/ui/impl-trait/auto-trait-leak.stderr
+++ b/tests/ui/impl-trait/auto-trait-leak.stderr
@@ -22,5 +22,5 @@ note: required by a bound in `send`
 LL | fn send<T: Send>(_: T) {}
    |            ^^^^ required by this bound in `send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/coherence-treats-tait-ambig.stderr b/tests/ui/impl-trait/coherence-treats-tait-ambig.stderr
index 7c69c4bfe97..faaad276927 100644
--- a/tests/ui/impl-trait/coherence-treats-tait-ambig.stderr
+++ b/tests/ui/impl-trait/coherence-treats-tait-ambig.stderr
@@ -8,6 +8,6 @@ LL | impl Into<T> for Foo {
            - impl<T, U> Into<U> for T
              where U: From<T>;
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/impl-trait/diagnostics/fully-qualified-path-impl-trait.stderr b/tests/ui/impl-trait/diagnostics/fully-qualified-path-impl-trait.stderr
index a1a629bddbd..06b5ae6e3b0 100644
--- a/tests/ui/impl-trait/diagnostics/fully-qualified-path-impl-trait.stderr
+++ b/tests/ui/impl-trait/diagnostics/fully-qualified-path-impl-trait.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     ().foo(|| ())
    |        ^^^ cannot infer type for type parameter `T` declared on the trait `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/does-not-live-long-enough.stderr b/tests/ui/impl-trait/does-not-live-long-enough.stderr
index 750687e2322..cfc13298071 100644
--- a/tests/ui/impl-trait/does-not-live-long-enough.stderr
+++ b/tests/ui/impl-trait/does-not-live-long-enough.stderr
@@ -16,6 +16,6 @@ help: to force the closure to take ownership of `prefix` (and any other referenc
 LL |         self.data.iter().filter(move |s| s.starts_with(prefix)).map(|s| s.as_ref())
    |                                 ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/impl-trait/dont-suggest-box-on-empty-else-arm.stderr b/tests/ui/impl-trait/dont-suggest-box-on-empty-else-arm.stderr
index 9b63911da7a..ea3d7f324a5 100644
--- a/tests/ui/impl-trait/dont-suggest-box-on-empty-else-arm.stderr
+++ b/tests/ui/impl-trait/dont-suggest-box-on-empty-else-arm.stderr
@@ -11,6 +11,6 @@ LL | |
 LL | |     }
    | |_____^ expected `&str`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/explicit-generic-args-for-impl.stderr b/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/explicit-generic-args-for-impl.stderr
index 9c101101870..e8cd16bc301 100644
--- a/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/explicit-generic-args-for-impl.stderr
+++ b/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/explicit-generic-args-for-impl.stderr
@@ -13,6 +13,6 @@ LL | fn foo<T: ?Sized>(_f: impl AsRef<T>) {}
    |    ^^^ -
    = note: `impl Trait` cannot be explicitly specified as a generic argument
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/not-enough-args.stderr b/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/not-enough-args.stderr
index a26460c8ecc..b2478c4cd29 100644
--- a/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/not-enough-args.stderr
+++ b/tests/ui/impl-trait/explicit-generic-args-with-impl-trait/not-enough-args.stderr
@@ -16,6 +16,6 @@ help: add missing generic argument
 LL |     f::<[u8], U>("a", b"a");
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/impl-trait/extra-item.stderr b/tests/ui/impl-trait/extra-item.stderr
index 728bcc0aa86..62299707287 100644
--- a/tests/ui/impl-trait/extra-item.stderr
+++ b/tests/ui/impl-trait/extra-item.stderr
@@ -4,6 +4,6 @@ error[E0407]: method `extra` is not a member of trait `extra_item::MyTrait`
 LL |     fn extra() {}
    |     ^^^^^^^^^^^^^ not a member of trait `extra_item::MyTrait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0407`.
diff --git a/tests/ui/impl-trait/fallback_inference.stderr b/tests/ui/impl-trait/fallback_inference.stderr
index 4ac3c238fe9..4f8121ae879 100644
--- a/tests/ui/impl-trait/fallback_inference.stderr
+++ b/tests/ui/impl-trait/fallback_inference.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     PhantomData::<T>
    |                +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2015.stderr b/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2015.stderr
index edf3911e2a0..6e36922b469 100644
--- a/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2015.stderr
+++ b/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2015.stderr
@@ -4,6 +4,6 @@ error[E0277]: the trait bound `(): AsRef<(dyn for<'a> Fn(&'a ()) + 'static)>` is
 LL | fn ice() -> impl AsRef<Fn(&())> {
    |             ^^^^^^^^^^^^^^^^^^^ the trait `AsRef<(dyn for<'a> Fn(&'a ()) + 'static)>` is not implemented for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2021.stderr b/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2021.stderr
index 30fbba16868..2e13ca753fc 100644
--- a/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2021.stderr
+++ b/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2021.stderr
@@ -9,6 +9,6 @@ help: add `dyn` keyword before this trait
 LL | fn ice() -> impl AsRef<dyn Fn(&())> {
    |                        +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0782`.
diff --git a/tests/ui/impl-trait/impl-fn-hrtb-bounds-2.stderr b/tests/ui/impl-trait/impl-fn-hrtb-bounds-2.stderr
index 835f7f76560..4e453c108d4 100644
--- a/tests/ui/impl-trait/impl-fn-hrtb-bounds-2.stderr
+++ b/tests/ui/impl-trait/impl-fn-hrtb-bounds-2.stderr
@@ -8,6 +8,6 @@ LL |     |x| x
    |     |
    |     hidden type `&u8` captures the anonymous lifetime as defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/impl-generic-mismatch-ab.stderr b/tests/ui/impl-trait/impl-generic-mismatch-ab.stderr
index db97fc2bdc4..7046e729e18 100644
--- a/tests/ui/impl-trait/impl-generic-mismatch-ab.stderr
+++ b/tests/ui/impl-trait/impl-generic-mismatch-ab.stderr
@@ -18,6 +18,6 @@ LL |     fn foo<A: Debug>(&self, a: &A, b: &impl Debug);
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/impl-trait/impl-trait-in-macro.stderr b/tests/ui/impl-trait/impl-trait-in-macro.stderr
index 7cfbe3447b8..4380f47c5de 100644
--- a/tests/ui/impl-trait/impl-trait-in-macro.stderr
+++ b/tests/ui/impl-trait/impl-trait-in-macro.stderr
@@ -17,6 +17,6 @@ LL |     a = y;
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-assoc-type.stderr b/tests/ui/impl-trait/in-assoc-type.stderr
index af60da07cac..d5b543ea953 100644
--- a/tests/ui/impl-trait/in-assoc-type.stderr
+++ b/tests/ui/impl-trait/in-assoc-type.stderr
@@ -17,6 +17,6 @@ note: this item must have the opaque type in its signature in order to be able t
 LL |     fn foo(&self) -> <Self as Foo<()>>::Bar {}
    |        ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr b/tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr
index 7c9028a8cd5..79a86b0a3ae 100644
--- a/tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr
+++ b/tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr
@@ -9,6 +9,6 @@ LL |     async fn foo() -> &'static impl T;
    |
    = help: consider adding an explicit lifetime bound `<Self as MyTrait>::{opaque#0}: 'static`...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/impl-trait/in-trait/bad-item-bound-within-rpitit.stderr b/tests/ui/impl-trait/in-trait/bad-item-bound-within-rpitit.stderr
index 324eaa37a3d..c898d17f4b7 100644
--- a/tests/ui/impl-trait/in-trait/bad-item-bound-within-rpitit.stderr
+++ b/tests/ui/impl-trait/in-trait/bad-item-bound-within-rpitit.stderr
@@ -28,6 +28,6 @@ help: replace the return type so that it matches the trait
 LL |     fn iter(&self) -> impl Iterator<Item = <Self as Iterable>::Item<'_>> + '_ {
    |                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/impl-trait/in-trait/check-wf-on-non-defaulted-rpitit.stderr b/tests/ui/impl-trait/in-trait/check-wf-on-non-defaulted-rpitit.stderr
index 1570b2ecd53..86f9cc4d992 100644
--- a/tests/ui/impl-trait/in-trait/check-wf-on-non-defaulted-rpitit.stderr
+++ b/tests/ui/impl-trait/in-trait/check-wf-on-non-defaulted-rpitit.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `Wrapper`
 LL | struct Wrapper<G: Send>(G);
    |                   ^^^^ required by this bound in `Wrapper`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/in-trait/deep-match.stderr b/tests/ui/impl-trait/in-trait/deep-match.stderr
index a658d8fa078..8ec30239ea8 100644
--- a/tests/ui/impl-trait/in-trait/deep-match.stderr
+++ b/tests/ui/impl-trait/in-trait/deep-match.stderr
@@ -10,6 +10,6 @@ LL |     fn bar() -> i32 {
    = note: expected struct `Wrapper<_>`
                 found type `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr b/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
index fcace10cd01..77f6945f064 100644
--- a/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
+++ b/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
@@ -6,6 +6,6 @@ LL |         42
    |         |
    |         expected `String`, found integer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-trait/default-body-type-err.stderr b/tests/ui/impl-trait/in-trait/default-body-type-err.stderr
index 596ff101155..6f1ac4bce43 100644
--- a/tests/ui/impl-trait/in-trait/default-body-type-err.stderr
+++ b/tests/ui/impl-trait/in-trait/default-body-type-err.stderr
@@ -7,6 +7,6 @@ LL |
 LL |         &1i32
    |         ----- return type was inferred to be `&i32` here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/impl-trait/in-trait/doesnt-satisfy.stderr b/tests/ui/impl-trait/in-trait/doesnt-satisfy.stderr
index cd45c6a9c6d..baee1b5db6e 100644
--- a/tests/ui/impl-trait/in-trait/doesnt-satisfy.stderr
+++ b/tests/ui/impl-trait/in-trait/doesnt-satisfy.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `Foo::{opaque#0}`
 LL |     fn bar() -> impl std::fmt::Display;
    |                      ^^^^^^^^^^^^^^^^^ required by this bound in `Foo::{opaque#0}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/in-trait/dont-project-to-rpitit-with-no-value.stderr b/tests/ui/impl-trait/in-trait/dont-project-to-rpitit-with-no-value.stderr
index 830e663da37..39f70e41357 100644
--- a/tests/ui/impl-trait/in-trait/dont-project-to-rpitit-with-no-value.stderr
+++ b/tests/ui/impl-trait/in-trait/dont-project-to-rpitit-with-no-value.stderr
@@ -7,6 +7,6 @@ LL |     fn foo(&self) -> impl Sized;
 LL | impl MyTrait for i32 {
    | ^^^^^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/impl-trait/in-trait/foreign-dyn-error.stderr b/tests/ui/impl-trait/in-trait/foreign-dyn-error.stderr
index f29ec95d594..9cc4c4b2f9e 100644
--- a/tests/ui/impl-trait/in-trait/foreign-dyn-error.stderr
+++ b/tests/ui/impl-trait/in-trait/foreign-dyn-error.stderr
@@ -11,6 +11,6 @@ LL |     fn bar(self) -> impl Deref<Target = impl Sized>;
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait cannot be made into an object because method `bar` references an `impl Trait` type in its return type
    = help: only type `rpitit::Foreign` implements the trait, consider using it directly instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/impl-trait/in-trait/generics-mismatch.stderr b/tests/ui/impl-trait/in-trait/generics-mismatch.stderr
index 043dbc8db5d..d847065ebc2 100644
--- a/tests/ui/impl-trait/in-trait/generics-mismatch.stderr
+++ b/tests/ui/impl-trait/in-trait/generics-mismatch.stderr
@@ -7,6 +7,6 @@ LL |     fn bar(&self) -> impl Sized;
 LL |     fn bar<T>(&self) {}
    |            ^ found 1 type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0049`.
diff --git a/tests/ui/impl-trait/in-trait/issue-102571.stderr b/tests/ui/impl-trait/in-trait/issue-102571.stderr
index 872988faf7a..1f25069a016 100644
--- a/tests/ui/impl-trait/in-trait/issue-102571.stderr
+++ b/tests/ui/impl-trait/in-trait/issue-102571.stderr
@@ -9,6 +9,6 @@ LL |     let () = t.bar();
    = note: expected associated type `impl Deref<Target = impl std::fmt::Display + ?Sized>`
                     found unit type `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-trait/method-signature-matches.lt.stderr b/tests/ui/impl-trait/in-trait/method-signature-matches.lt.stderr
index 874a1b95a43..59ffea6fb9f 100644
--- a/tests/ui/impl-trait/in-trait/method-signature-matches.lt.stderr
+++ b/tests/ui/impl-trait/in-trait/method-signature-matches.lt.stderr
@@ -16,6 +16,6 @@ LL |     fn early<'early, T>(x: &'early T) -> impl Sized;
    = note: expected signature `fn(&T)`
               found signature `fn(&'late ())`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch.stderr b/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch.stderr
index e0bd1cc4f19..f8980828b89 100644
--- a/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch.stderr
+++ b/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch.stderr
@@ -15,6 +15,6 @@ LL |     fn owo(x: ()) -> impl Sized;
    = note: expected signature `fn(())`
               found signature `fn(u8)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch_async.stderr b/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch_async.stderr
index 096e96c85c4..a6fb1a200e6 100644
--- a/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch_async.stderr
+++ b/tests/ui/impl-trait/in-trait/method-signature-matches.mismatch_async.stderr
@@ -15,6 +15,6 @@ LL |     async fn owo(x: ()) {}
    = note: expected signature `fn(()) -> _`
               found signature `fn(u8) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/impl-trait/in-trait/method-signature-matches.too_few.stderr b/tests/ui/impl-trait/in-trait/method-signature-matches.too_few.stderr
index 96eff1a5815..0b26e039e6b 100644
--- a/tests/ui/impl-trait/in-trait/method-signature-matches.too_few.stderr
+++ b/tests/ui/impl-trait/in-trait/method-signature-matches.too_few.stderr
@@ -7,6 +7,6 @@ LL |     fn come_on_a_little_more_effort(_: (), _: (), _: ()) -> impl Sized;
 LL |     fn come_on_a_little_more_effort() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 3 parameters, found 0
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0050`.
diff --git a/tests/ui/impl-trait/in-trait/method-signature-matches.too_many.stderr b/tests/ui/impl-trait/in-trait/method-signature-matches.too_many.stderr
index 0fc847051c9..9226e1f8b98 100644
--- a/tests/ui/impl-trait/in-trait/method-signature-matches.too_many.stderr
+++ b/tests/ui/impl-trait/in-trait/method-signature-matches.too_many.stderr
@@ -7,6 +7,6 @@ LL |     fn calm_down_please() -> impl Sized;
 LL |     fn calm_down_please(_: (), _: (), _: ()) {}
    |                            ^^^^^^^^^^^^^^^^ expected 0 parameters, found 3
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0050`.
diff --git a/tests/ui/impl-trait/in-trait/missing-lt-outlives-in-rpitit-114274.stderr b/tests/ui/impl-trait/in-trait/missing-lt-outlives-in-rpitit-114274.stderr
index 1fd678a1f3a..3e763c9f1df 100644
--- a/tests/ui/impl-trait/in-trait/missing-lt-outlives-in-rpitit-114274.stderr
+++ b/tests/ui/impl-trait/in-trait/missing-lt-outlives-in-rpitit-114274.stderr
@@ -18,6 +18,6 @@ help: consider introducing lifetime `'missing` here
 LL | trait Iterable<'missing> {
    |               ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0261`.
diff --git a/tests/ui/impl-trait/in-trait/opaque-in-impl-is-opaque.stderr b/tests/ui/impl-trait/in-trait/opaque-in-impl-is-opaque.stderr
index e260762d89f..4996e6839e9 100644
--- a/tests/ui/impl-trait/in-trait/opaque-in-impl-is-opaque.stderr
+++ b/tests/ui/impl-trait/in-trait/opaque-in-impl-is-opaque.stderr
@@ -12,6 +12,6 @@ LL |     let x: &str = ().bar();
    = note: expected reference `&str`
             found opaque type `impl std::fmt::Display`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr b/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
index 181d6a284da..db587d069f8 100644
--- a/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
+++ b/tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `Foo::{opaque#0}`
 LL |     fn foo<F2>(self) -> impl Foo<T>;
    |                              ^^^^^^ required by this bound in `Foo::{opaque#0}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr
index afc59cc5b58..5ace64b6903 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr
+++ b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf-via-param.stderr
@@ -11,6 +11,6 @@ note: but the referenced data is only valid for the lifetime `'a` as defined her
 LL |     fn extend<'a: 'a>(s: &'a str) -> (Option<&'static &'a ()>, &'static str)
    |               ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf.stderr b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf.stderr
index 7e1a8f083ac..3430055dab1 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf.stderr
+++ b/tests/ui/impl-trait/in-trait/rpitit-hidden-types-self-implied-wf.stderr
@@ -11,6 +11,6 @@ note: but the referenced data is only valid for the anonymous lifetime defined h
 LL |     fn extend(s: &str) -> (Option<&'static &'_ ()>, &'static str) {
    |                  ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/impl-trait/in-trait/rpitit-shadowed-by-missing-adt.stderr b/tests/ui/impl-trait/in-trait/rpitit-shadowed-by-missing-adt.stderr
index 6e4a5bb5df3..73ada8d7096 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-shadowed-by-missing-adt.stderr
+++ b/tests/ui/impl-trait/in-trait/rpitit-shadowed-by-missing-adt.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Missing` in this scope
 LL |     fn w() -> impl Deref<Target = Missing<impl Sized>>;
    |                                   ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/impl-trait/in-trait/sibling-function-constraint.stderr b/tests/ui/impl-trait/in-trait/sibling-function-constraint.stderr
index 729963a8141..b8ac826adaa 100644
--- a/tests/ui/impl-trait/in-trait/sibling-function-constraint.stderr
+++ b/tests/ui/impl-trait/in-trait/sibling-function-constraint.stderr
@@ -12,6 +12,6 @@ LL |     fn bar() -> impl Sized {
    = note:   expected struct `String`
            found opaque type `impl Sized`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/in-trait/signature-mismatch.failure.stderr b/tests/ui/impl-trait/in-trait/signature-mismatch.failure.stderr
index 468cf12f1bc..0cd76815afa 100644
--- a/tests/ui/impl-trait/in-trait/signature-mismatch.failure.stderr
+++ b/tests/ui/impl-trait/in-trait/signature-mismatch.failure.stderr
@@ -9,6 +9,6 @@ LL |     ) -> impl Future<Output = Vec<u8>> {
    |          |
    |          ...but data from `buff` is returned here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0623`.
diff --git a/tests/ui/impl-trait/in-trait/suggest-missing-item.stderr b/tests/ui/impl-trait/in-trait/suggest-missing-item.stderr
index cec94e39a35..cf68ed87030 100644
--- a/tests/ui/impl-trait/in-trait/suggest-missing-item.stderr
+++ b/tests/ui/impl-trait/in-trait/suggest-missing-item.stderr
@@ -16,6 +16,6 @@ LL |     async fn baz(&self) -> &i32;
 LL | impl Trait for S {}
    | ^^^^^^^^^^^^^^^^ missing `foo`, `bar`, `test`, `baz` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/impl-trait/in-trait/trait-more-generics-than-impl.stderr b/tests/ui/impl-trait/in-trait/trait-more-generics-than-impl.stderr
index 2836e9c7821..eed4c07710e 100644
--- a/tests/ui/impl-trait/in-trait/trait-more-generics-than-impl.stderr
+++ b/tests/ui/impl-trait/in-trait/trait-more-generics-than-impl.stderr
@@ -7,6 +7,6 @@ LL |     fn bar<T>() -> impl Sized;
 LL |     fn bar() -> impl Sized {}
    |           ^ found 0 type parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0049`.
diff --git a/tests/ui/impl-trait/in-trait/unconstrained-lt.stderr b/tests/ui/impl-trait/in-trait/unconstrained-lt.stderr
index 61a0f8454d1..4c5a42c0b4b 100644
--- a/tests/ui/impl-trait/in-trait/unconstrained-lt.stderr
+++ b/tests/ui/impl-trait/in-trait/unconstrained-lt.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a, T> Foo for T {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/impl-trait/issue-100075-2.stderr b/tests/ui/impl-trait/issue-100075-2.stderr
index d2dbd8c6205..b3b69677507 100644
--- a/tests/ui/impl-trait/issue-100075-2.stderr
+++ b/tests/ui/impl-trait/issue-100075-2.stderr
@@ -19,6 +19,6 @@ LL | fn opaque<T>(t: T) -> impl Sized {
 LL |     opaque(Some(t))
    |     --------------- returning here with type `impl Sized`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0720`.
diff --git a/tests/ui/impl-trait/issue-100075.stderr b/tests/ui/impl-trait/issue-100075.stderr
index 267ecfdaed1..75963489236 100644
--- a/tests/ui/impl-trait/issue-100075.stderr
+++ b/tests/ui/impl-trait/issue-100075.stderr
@@ -7,6 +7,6 @@ LL | fn _g<T>(t: &'static T) -> &'static impl Marker {
 LL |         return _g(t);
    |                ----- returning here with type `&impl Marker`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0720`.
diff --git a/tests/ui/impl-trait/issue-103181-1.current.stderr b/tests/ui/impl-trait/issue-103181-1.current.stderr
index e87a9d28ae1..83410dfc6ea 100644
--- a/tests/ui/impl-trait/issue-103181-1.current.stderr
+++ b/tests/ui/impl-trait/issue-103181-1.current.stderr
@@ -7,6 +7,6 @@ LL |     }
 LL |     impl HttpBody for () {
    |     ^^^^^^^^^^^^^^^^^^^^ missing `Error` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/impl-trait/issue-103181-1.next.stderr b/tests/ui/impl-trait/issue-103181-1.next.stderr
index e87a9d28ae1..83410dfc6ea 100644
--- a/tests/ui/impl-trait/issue-103181-1.next.stderr
+++ b/tests/ui/impl-trait/issue-103181-1.next.stderr
@@ -7,6 +7,6 @@ LL |     }
 LL |     impl HttpBody for () {
    |     ^^^^^^^^^^^^^^^^^^^^ missing `Error` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/impl-trait/issue-103181-2.stderr b/tests/ui/impl-trait/issue-103181-2.stderr
index 5eb2dd9184b..cef4449dbb9 100644
--- a/tests/ui/impl-trait/issue-103181-2.stderr
+++ b/tests/ui/impl-trait/issue-103181-2.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `ident_error` in this scope
 LL |     ident_error;
    |     ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/impl-trait/issue-35668.stderr b/tests/ui/impl-trait/issue-35668.stderr
index 84add5799ab..ba02d2898e9 100644
--- a/tests/ui/impl-trait/issue-35668.stderr
+++ b/tests/ui/impl-trait/issue-35668.stderr
@@ -11,6 +11,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn func<'a, T>(a: &'a [T]) -> impl Iterator<Item=&'a T> where &T: Mul<&T> {
    |                                                         +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/impl-trait/issue-54966.stderr b/tests/ui/impl-trait/issue-54966.stderr
index aa9a61cb592..4024c5afa80 100644
--- a/tests/ui/impl-trait/issue-54966.stderr
+++ b/tests/ui/impl-trait/issue-54966.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Oper` in this scope
 LL | fn generate_duration() -> Oper<impl FnMut()> {}
    |                           ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/impl-trait/issue-55872-3.stderr b/tests/ui/impl-trait/issue-55872-3.stderr
index b542b614199..9af0fad9cdb 100644
--- a/tests/ui/impl-trait/issue-55872-3.stderr
+++ b/tests/ui/impl-trait/issue-55872-3.stderr
@@ -4,6 +4,6 @@ error[E0277]: the trait bound `{async block@$DIR/issue-55872-3.rs:15:9: 15:17}:
 LL |     fn foo<T>() -> Self::E {
    |                    ^^^^^^^ the trait `Copy` is not implemented for `{async block@$DIR/issue-55872-3.rs:15:9: 15:17}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/issue-55872.stderr b/tests/ui/impl-trait/issue-55872.stderr
index cb370fbe1c4..4ff8527bbe9 100644
--- a/tests/ui/impl-trait/issue-55872.stderr
+++ b/tests/ui/impl-trait/issue-55872.stderr
@@ -4,5 +4,5 @@ error: type parameter `T` is part of concrete type but not used in parameter lis
 LL |         || ()
    |         ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issue-86465.stderr b/tests/ui/impl-trait/issue-86465.stderr
index 90d6904ed61..e330d178d4e 100644
--- a/tests/ui/impl-trait/issue-86465.stderr
+++ b/tests/ui/impl-trait/issue-86465.stderr
@@ -7,5 +7,5 @@ LL |     (a, a)
    |     expected `&'a u32`, got `&'b u32`
    |     this expression supplies two conflicting concrete types for the same opaque type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issue-87450.stderr b/tests/ui/impl-trait/issue-87450.stderr
index 173fca63fa0..9567e09651d 100644
--- a/tests/ui/impl-trait/issue-87450.stderr
+++ b/tests/ui/impl-trait/issue-87450.stderr
@@ -22,6 +22,6 @@ LL |     wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo())))))))
 LL | fn wrap(f: impl Fn()) -> impl Fn() {
    |                          --------- returning this opaque type `impl Fn()`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0720`.
diff --git a/tests/ui/impl-trait/issue-99914.stderr b/tests/ui/impl-trait/issue-99914.stderr
index c86e9eadc87..06e85e521d2 100644
--- a/tests/ui/impl-trait/issue-99914.stderr
+++ b/tests/ui/impl-trait/issue-99914.stderr
@@ -9,6 +9,6 @@ help: try wrapping the expression in `Ok`
 LL |     t.and_then(|t| -> _ { Ok(bar(t)) });
    |                           +++      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/issues/issue-21659-show-relevant-trait-impls-3.stderr b/tests/ui/impl-trait/issues/issue-21659-show-relevant-trait-impls-3.stderr
index 9150d957db7..e5d71839373 100644
--- a/tests/ui/impl-trait/issues/issue-21659-show-relevant-trait-impls-3.stderr
+++ b/tests/ui/impl-trait/issues/issue-21659-show-relevant-trait-impls-3.stderr
@@ -14,6 +14,6 @@ note: `Foo` defines an item `foo`, perhaps you need to implement it
 LL | trait Foo<A> {
    | ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/issues/issue-54600.stderr b/tests/ui/impl-trait/issues/issue-54600.stderr
index 9a8e3675b95..946ad74b872 100644
--- a/tests/ui/impl-trait/issues/issue-54600.stderr
+++ b/tests/ui/impl-trait/issues/issue-54600.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL |     let x: Option<impl Debug> = Some(44_u32);
    |                   ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-54840.stderr b/tests/ui/impl-trait/issues/issue-54840.stderr
index 67cabf44950..c4ab79f110d 100644
--- a/tests/ui/impl-trait/issues/issue-54840.stderr
+++ b/tests/ui/impl-trait/issues/issue-54840.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL |     let j: &impl Add = &i;
    |             ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-54895.stderr b/tests/ui/impl-trait/issues/issue-54895.stderr
index 7d22f027a6d..999ffd52141 100644
--- a/tests/ui/impl-trait/issues/issue-54895.stderr
+++ b/tests/ui/impl-trait/issues/issue-54895.stderr
@@ -10,5 +10,5 @@ note: lifetime declared here
 LL | fn f() -> impl for<'a> Trait<'a, Out = impl Sized + 'a> {
    |                    ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issues/issue-57979-deeply-nested-impl-trait-in-assoc-proj.stderr b/tests/ui/impl-trait/issues/issue-57979-deeply-nested-impl-trait-in-assoc-proj.stderr
index 6bebbc01f3d..83d0d776572 100644
--- a/tests/ui/impl-trait/issues/issue-57979-deeply-nested-impl-trait-in-assoc-proj.stderr
+++ b/tests/ui/impl-trait/issues/issue-57979-deeply-nested-impl-trait-in-assoc-proj.stderr
@@ -7,6 +7,6 @@ LL | pub fn demo(_: impl Quux<Assoc=Deeper<impl Foo<impl Bar>>>) { }
    |                                       |        nested `impl Trait` here
    |                                       outer `impl Trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0666`.
diff --git a/tests/ui/impl-trait/issues/issue-57979-impl-trait-in-path.stderr b/tests/ui/impl-trait/issues/issue-57979-impl-trait-in-path.stderr
index e31393181d7..55f47785f0e 100644
--- a/tests/ui/impl-trait/issues/issue-57979-impl-trait-in-path.stderr
+++ b/tests/ui/impl-trait/issues/issue-57979-impl-trait-in-path.stderr
@@ -4,6 +4,6 @@ error[E0667]: `impl Trait` is not allowed in path parameters
 LL | pub fn demo(_: impl Quux<(), Assoc=<() as Quux<impl Bar>>::Assoc>) { }
    |                                                ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0667`.
diff --git a/tests/ui/impl-trait/issues/issue-57979-nested-impl-trait-in-assoc-proj.stderr b/tests/ui/impl-trait/issues/issue-57979-nested-impl-trait-in-assoc-proj.stderr
index 8d3d4b5e206..0e105817b18 100644
--- a/tests/ui/impl-trait/issues/issue-57979-nested-impl-trait-in-assoc-proj.stderr
+++ b/tests/ui/impl-trait/issues/issue-57979-nested-impl-trait-in-assoc-proj.stderr
@@ -7,6 +7,6 @@ LL | pub fn demo(_: impl Quux<Assoc=impl Foo<impl Bar>>) { }
    |                                |        nested `impl Trait` here
    |                                outer `impl Trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0666`.
diff --git a/tests/ui/impl-trait/issues/issue-58504.stderr b/tests/ui/impl-trait/issues/issue-58504.stderr
index 49376f559cf..e67e48728ed 100644
--- a/tests/ui/impl-trait/issues/issue-58504.stderr
+++ b/tests/ui/impl-trait/issues/issue-58504.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL |     let gens: [impl Coroutine<Return=!, Yield=()>;2] = [ mk_gen(), mk_gen() ];
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-67830.stderr b/tests/ui/impl-trait/issues/issue-67830.stderr
index d3ea8cb0377..17cfa151a68 100644
--- a/tests/ui/impl-trait/issues/issue-67830.stderr
+++ b/tests/ui/impl-trait/issues/issue-67830.stderr
@@ -10,5 +10,5 @@ note: lifetime declared here
 LL | fn test() -> impl for<'a> MyFn<&'a A, Output=impl Iterator + 'a> {
    |                       ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issues/issue-70877.stderr b/tests/ui/impl-trait/issues/issue-70877.stderr
index ee140e6f6c4..274139f01d0 100644
--- a/tests/ui/impl-trait/issues/issue-70877.stderr
+++ b/tests/ui/impl-trait/issues/issue-70877.stderr
@@ -15,5 +15,5 @@ note: opaque type being used as hidden type
 LL | type FooRet = impl std::fmt::Debug;
    |               ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issues/issue-70971.stderr b/tests/ui/impl-trait/issues/issue-70971.stderr
index 5609f8b9b01..fcc67291e4d 100644
--- a/tests/ui/impl-trait/issues/issue-70971.stderr
+++ b/tests/ui/impl-trait/issues/issue-70971.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL |     let x : (impl Copy,) = (true,);
    |              ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-82139.stderr b/tests/ui/impl-trait/issues/issue-82139.stderr
index 0adcd4a7a2f..b8708443312 100644
--- a/tests/ui/impl-trait/issues/issue-82139.stderr
+++ b/tests/ui/impl-trait/issues/issue-82139.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `j` in this scope
 LL |         Some(42).map(|_| j)
    |                          ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/impl-trait/issues/issue-83919.stderr b/tests/ui/impl-trait/issues/issue-83919.stderr
index d39dcf7fbf5..200257235fe 100644
--- a/tests/ui/impl-trait/issues/issue-83919.stderr
+++ b/tests/ui/impl-trait/issues/issue-83919.stderr
@@ -7,6 +7,6 @@ LL |     fn get_fut(&self) -> Self::Fut {
    = help: the trait `Future` is not implemented for `{integer}`
    = note: {integer} must be a future or must implement `IntoFuture` to be awaited
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/issues/issue-84073.stderr b/tests/ui/impl-trait/issues/issue-84073.stderr
index b4be16ff042..d03e458aeb8 100644
--- a/tests/ui/impl-trait/issues/issue-84073.stderr
+++ b/tests/ui/impl-trait/issues/issue-84073.stderr
@@ -9,6 +9,6 @@ help: consider giving this closure parameter an explicit type, where the type fo
 LL |     Race::new(|race: RaceBuilder<T, Never<T>>| race.when());
    |                    ++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/issues/issue-84919.stderr b/tests/ui/impl-trait/issues/issue-84919.stderr
index 20b131b8bd2..963865efa69 100644
--- a/tests/ui/impl-trait/issues/issue-84919.stderr
+++ b/tests/ui/impl-trait/issues/issue-84919.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL |     let _x: impl Trait = ();
    |             ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-86642.stderr b/tests/ui/impl-trait/issues/issue-86642.stderr
index 6d3be3fff0e..3ad18a13290 100644
--- a/tests/ui/impl-trait/issues/issue-86642.stderr
+++ b/tests/ui/impl-trait/issues/issue-86642.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL | static x: impl Fn(&str) -> Result<&str, ()> = move |source| {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-87295.stderr b/tests/ui/impl-trait/issues/issue-87295.stderr
index 3fe4ee73c80..e9a635f244b 100644
--- a/tests/ui/impl-trait/issues/issue-87295.stderr
+++ b/tests/ui/impl-trait/issues/issue-87295.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL |     let _do_not_waste: Struct<impl Trait<Output = i32>> = Struct::new(());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/impl-trait/issues/issue-87340.stderr b/tests/ui/impl-trait/issues/issue-87340.stderr
index 2ab1e6a0312..8513cb2881e 100644
--- a/tests/ui/impl-trait/issues/issue-87340.stderr
+++ b/tests/ui/impl-trait/issues/issue-87340.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T> X for () {
    |      ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/impl-trait/issues/issue-88236.stderr b/tests/ui/impl-trait/issues/issue-88236.stderr
index 7a4cc57b088..6cf1a42d6a9 100644
--- a/tests/ui/impl-trait/issues/issue-88236.stderr
+++ b/tests/ui/impl-trait/issues/issue-88236.stderr
@@ -10,5 +10,5 @@ note: lifetime declared here
 LL | fn make_impl() -> impl for<'a> Hrtb<'a, Assoc = impl Send + 'a> {}
    |                            ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issues/issue-92305.stderr b/tests/ui/impl-trait/issues/issue-92305.stderr
index 86d7184da7a..88fb1fb2707 100644
--- a/tests/ui/impl-trait/issues/issue-92305.stderr
+++ b/tests/ui/impl-trait/issues/issue-92305.stderr
@@ -9,6 +9,6 @@ help: add missing generic argument
 LL | fn f<T>(data: &[T]) -> impl Iterator<Item = Vec<T>> {
    |                                                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr b/tests/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr
index f0dceb1b11a..a83e0df911b 100644
--- a/tests/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr
+++ b/tests/ui/impl-trait/issues/issue-99348-impl-compatibility.stderr
@@ -20,6 +20,6 @@ note: required by a bound in `Foo::Item`
 LL |     type Item: Bar<Other = Self>;
    |                    ^^^^^^^^^^^^ required by this bound in `Foo::Item`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/impl-trait/method-suggestion-no-duplication.stderr b/tests/ui/impl-trait/method-suggestion-no-duplication.stderr
index b727b2ca0cc..c401269da83 100644
--- a/tests/ui/impl-trait/method-suggestion-no-duplication.stderr
+++ b/tests/ui/impl-trait/method-suggestion-no-duplication.stderr
@@ -11,6 +11,6 @@ LL |     foo(|s| s.is_empty());
    = note: the following trait defines an item `is_empty`, perhaps you need to implement it:
            candidate #1: `ExactSizeIterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/multiple-defining-usages-in-body.stderr b/tests/ui/impl-trait/multiple-defining-usages-in-body.stderr
index f3c090408b4..faa5d3ba448 100644
--- a/tests/ui/impl-trait/multiple-defining-usages-in-body.stderr
+++ b/tests/ui/impl-trait/multiple-defining-usages-in-body.stderr
@@ -22,5 +22,5 @@ note: previous use here
 LL |     let a: T = foo::<T, U>();
    |                ^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/impl-trait/multiple-lifetimes/error-handling-2.stderr b/tests/ui/impl-trait/multiple-lifetimes/error-handling-2.stderr
index 5b0b1cc5e42..b968592beff 100644
--- a/tests/ui/impl-trait/multiple-lifetimes/error-handling-2.stderr
+++ b/tests/ui/impl-trait/multiple-lifetimes/error-handling-2.stderr
@@ -10,6 +10,6 @@ LL | fn foo<'a: 'b, 'b, 'c>(x: &'static i32, mut y: &'a i32) -> E<'b, 'c> {
 LL |     u.0
    |     ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/multiple-lifetimes/error-handling.stderr b/tests/ui/impl-trait/multiple-lifetimes/error-handling.stderr
index 01d9f506a0c..00709ee7438 100644
--- a/tests/ui/impl-trait/multiple-lifetimes/error-handling.stderr
+++ b/tests/ui/impl-trait/multiple-lifetimes/error-handling.stderr
@@ -11,5 +11,5 @@ LL |         let _: &'b i32 = *u.0;
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unrelated.stderr b/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unrelated.stderr
index 68ac22a05f4..4d4ba58c974 100644
--- a/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unrelated.stderr
+++ b/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unrelated.stderr
@@ -14,6 +14,6 @@ help: to declare that `impl Trait<'d, 'e>` captures `'b`, you can add an explici
 LL | fn upper_bounds<'a, 'b, 'c, 'd, 'e>(a: Ordinary<'a>, b: Ordinary<'b>) -> impl Trait<'d, 'e> + 'b
    |                                                                                             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unsuited.stderr b/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unsuited.stderr
index 493a9e66eaf..060eaa7e64a 100644
--- a/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unsuited.stderr
+++ b/tests/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unsuited.stderr
@@ -14,6 +14,6 @@ help: to declare that `impl Trait<'a, 'b>` captures `'b`, you can add an explici
 LL | fn upper_bounds<'a, 'b>(a: Ordinary<'a>, b: Ordinary<'b>) -> impl Trait<'a, 'b> + 'b
    |                                                                                 ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/negative-reasoning.stderr b/tests/ui/impl-trait/negative-reasoning.stderr
index ddce5e7ece2..3cb4be16fc3 100644
--- a/tests/ui/impl-trait/negative-reasoning.stderr
+++ b/tests/ui/impl-trait/negative-reasoning.stderr
@@ -9,6 +9,6 @@ LL | impl AnotherTrait for D<OpaqueType> {
    |
    = note: upstream crates may add a new impl of trait `std::marker::FnPtr` for type `OpaqueType` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/impl-trait/nested-return-type4.stderr b/tests/ui/impl-trait/nested-return-type4.stderr
index a1e2d227ff3..14d51a1b064 100644
--- a/tests/ui/impl-trait/nested-return-type4.stderr
+++ b/tests/ui/impl-trait/nested-return-type4.stderr
@@ -17,6 +17,6 @@ help: to declare that `impl Sized` captures `'s`, you can add an explicit `'s` l
 LL | fn test<'s: 's>(s: &'s str) -> impl std::future::Future<Output = impl Sized + 's> {
    |                                                                             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/nested-rpit-hrtb-2.stderr b/tests/ui/impl-trait/nested-rpit-hrtb-2.stderr
index 71d1d45f48b..0fcacc19ca3 100644
--- a/tests/ui/impl-trait/nested-rpit-hrtb-2.stderr
+++ b/tests/ui/impl-trait/nested-rpit-hrtb-2.stderr
@@ -7,6 +7,6 @@ LL | fn test() -> impl for<'a> Trait<'a, Assoc = impl Sized> {}
    |                       |                     opaque type defined here
    |                       hidden type `&'a str` captures the lifetime `'a` as defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/no-trait.stderr b/tests/ui/impl-trait/no-trait.stderr
index 3a636f2524f..a58fa5cd711 100644
--- a/tests/ui/impl-trait/no-trait.stderr
+++ b/tests/ui/impl-trait/no-trait.stderr
@@ -4,5 +4,5 @@ error: at least one trait must be specified
 LL | fn f() -> impl 'static {}
    |           ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.stderr b/tests/ui/impl-trait/normalize-tait-in-const.stderr
index ada8fd7fa50..e0513433b8e 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.stderr
+++ b/tests/ui/impl-trait/normalize-tait-in-const.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
    |                                          ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr b/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr
index 2347805343c..5ade6a69d4b 100644
--- a/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr
+++ b/tests/ui/impl-trait/opaque-cast-field-access-in-future.stderr
@@ -6,6 +6,6 @@ LL | fn run() -> Foo<impl Future<Output = ()>> {
    |
    = note: cannot satisfy `_: Future`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/impl-trait/projection-mismatch-in-impl-where-clause.stderr b/tests/ui/impl-trait/projection-mismatch-in-impl-where-clause.stderr
index a4ff510477a..c4ea4474066 100644
--- a/tests/ui/impl-trait/projection-mismatch-in-impl-where-clause.stderr
+++ b/tests/ui/impl-trait/projection-mismatch-in-impl-where-clause.stderr
@@ -15,6 +15,6 @@ note: required for `()` to implement `Test`
 LL | impl<T> Test for T where T: Super<Assoc = ()> {}
    |         ^^^^     ^                ---------- unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/impl-trait/recursive-coroutine.current.stderr b/tests/ui/impl-trait/recursive-coroutine.current.stderr
index 45911b7fc11..e838634ed08 100644
--- a/tests/ui/impl-trait/recursive-coroutine.current.stderr
+++ b/tests/ui/impl-trait/recursive-coroutine.current.stderr
@@ -7,6 +7,6 @@ LL | fn foo() -> impl Coroutine<Yield = (), Return = ()> {
 LL |         let mut gen = Box::pin(foo());
    |             ------- coroutine captures itself here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0720`.
diff --git a/tests/ui/impl-trait/recursive-coroutine.next.stderr b/tests/ui/impl-trait/recursive-coroutine.next.stderr
index 45911b7fc11..e838634ed08 100644
--- a/tests/ui/impl-trait/recursive-coroutine.next.stderr
+++ b/tests/ui/impl-trait/recursive-coroutine.next.stderr
@@ -7,6 +7,6 @@ LL | fn foo() -> impl Coroutine<Yield = (), Return = ()> {
 LL |         let mut gen = Box::pin(foo());
    |             ------- coroutine captures itself here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0720`.
diff --git a/tests/ui/impl-trait/recursive-type-alias-impl-trait-declaration.stderr b/tests/ui/impl-trait/recursive-type-alias-impl-trait-declaration.stderr
index b98b859a99b..bc810c0f88f 100644
--- a/tests/ui/impl-trait/recursive-type-alias-impl-trait-declaration.stderr
+++ b/tests/ui/impl-trait/recursive-type-alias-impl-trait-declaration.stderr
@@ -10,6 +10,6 @@ LL |     Bar
    = help: the trait `PartialEq<(Foo, i32)>` is not implemented for `Bar`
    = help: the trait `PartialEq<(Bar, i32)>` is implemented for `Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/region-escape-via-bound.stderr b/tests/ui/impl-trait/region-escape-via-bound.stderr
index e4556bc21a7..43f0eeeb558 100644
--- a/tests/ui/impl-trait/region-escape-via-bound.stderr
+++ b/tests/ui/impl-trait/region-escape-via-bound.stderr
@@ -14,6 +14,6 @@ help: to declare that `impl Trait<'y>` captures `'x`, you can add an explicit `'
 LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x
    |                                                    ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/impl-trait/rpit-not-sized.stderr b/tests/ui/impl-trait/rpit-not-sized.stderr
index 608c94fc072..7fe275f06fb 100644
--- a/tests/ui/impl-trait/rpit-not-sized.stderr
+++ b/tests/ui/impl-trait/rpit-not-sized.stderr
@@ -7,6 +7,6 @@ LL | fn foo() -> impl ?Sized {
    = help: the trait `Sized` is not implemented for `impl ?Sized`
    = note: the return type of a function must have a statically known size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/suggest-calling-rpit-closure.stderr b/tests/ui/impl-trait/suggest-calling-rpit-closure.stderr
index c10a856d83b..b0ae10b8d86 100644
--- a/tests/ui/impl-trait/suggest-calling-rpit-closure.stderr
+++ b/tests/ui/impl-trait/suggest-calling-rpit-closure.stderr
@@ -16,6 +16,6 @@ help: use parentheses to call this opaque type
 LL |     opaque()()
    |             ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other.current.stderr b/tests/ui/impl-trait/two_tait_defining_each_other.current.stderr
index e5f7e5e5c44..b60529ed002 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other.current.stderr
+++ b/tests/ui/impl-trait/two_tait_defining_each_other.current.stderr
@@ -15,5 +15,5 @@ note: opaque type being used as hidden type
 LL | type A = impl Foo;
    |          ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr b/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
index e3a4797e44c..e49d1d18b0c 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
+++ b/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
@@ -4,6 +4,6 @@ error[E0284]: type annotations needed: cannot satisfy `A <: B`
 LL |     x // B's hidden type is A (opaquely)
    |     ^ cannot satisfy `A <: B`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other3.current.stderr b/tests/ui/impl-trait/two_tait_defining_each_other3.current.stderr
index 451ba407b71..1dccfd17a70 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other3.current.stderr
+++ b/tests/ui/impl-trait/two_tait_defining_each_other3.current.stderr
@@ -15,5 +15,5 @@ note: opaque type being used as hidden type
 LL | type A = impl Foo;
    |          ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/type-arg-mismatch-due-to-impl-trait.stderr b/tests/ui/impl-trait/type-arg-mismatch-due-to-impl-trait.stderr
index 30322f88cca..d3d651a28e1 100644
--- a/tests/ui/impl-trait/type-arg-mismatch-due-to-impl-trait.stderr
+++ b/tests/ui/impl-trait/type-arg-mismatch-due-to-impl-trait.stderr
@@ -10,6 +10,6 @@ LL |     fn foo(&self, t: impl Clone) {}
    |                      found 1 type parameter
    |                      `impl Trait` introduces an implicit type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0049`.
diff --git a/tests/ui/impl-trait/type_parameters_captured.stderr b/tests/ui/impl-trait/type_parameters_captured.stderr
index 46859296fb8..28dfcd8b871 100644
--- a/tests/ui/impl-trait/type_parameters_captured.stderr
+++ b/tests/ui/impl-trait/type_parameters_captured.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn foo<T: 'static>(x: T) -> impl Any + 'static {
    |         +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/impl-trait/unactionable_diagnostic.stderr b/tests/ui/impl-trait/unactionable_diagnostic.stderr
index 4df7f45c3b3..be37da08e76 100644
--- a/tests/ui/impl-trait/unactionable_diagnostic.stderr
+++ b/tests/ui/impl-trait/unactionable_diagnostic.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | pub fn bar<'t, T: 't>(
    |                 ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/impl-trait/universal-mismatched-type.stderr b/tests/ui/impl-trait/universal-mismatched-type.stderr
index 82e0f23964f..21da1d087ac 100644
--- a/tests/ui/impl-trait/universal-mismatched-type.stderr
+++ b/tests/ui/impl-trait/universal-mismatched-type.stderr
@@ -11,6 +11,6 @@ LL |     x
    = note:      expected struct `String`
            found type parameter `impl Debug`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/universal-two-impl-traits.stderr b/tests/ui/impl-trait/universal-two-impl-traits.stderr
index ab8a53d0db3..3b4844ab133 100644
--- a/tests/ui/impl-trait/universal-two-impl-traits.stderr
+++ b/tests/ui/impl-trait/universal-two-impl-traits.stderr
@@ -15,6 +15,6 @@ LL |     a = y;
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/universal_wrong_hrtb.stderr b/tests/ui/impl-trait/universal_wrong_hrtb.stderr
index b5a091b61fa..e0718927976 100644
--- a/tests/ui/impl-trait/universal_wrong_hrtb.stderr
+++ b/tests/ui/impl-trait/universal_wrong_hrtb.stderr
@@ -4,5 +4,5 @@ error: `impl Trait` can only mention lifetimes from an fn or impl
 LL | fn test_argument_position(x: impl for<'a> Trait<'a, Assoc = impl Copy + 'a>) {}
    |                                       -- lifetime declared here         ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/where-allowed-2.stderr b/tests/ui/impl-trait/where-allowed-2.stderr
index b3765ac1a54..c421e587a9e 100644
--- a/tests/ui/impl-trait/where-allowed-2.stderr
+++ b/tests/ui/impl-trait/where-allowed-2.stderr
@@ -6,6 +6,6 @@ LL | fn in_adt_in_return() -> Vec<impl Debug> { panic!() }
    |
    = note: cannot satisfy `_: Debug`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/impl-unused-rps-in-assoc-type.stderr b/tests/ui/impl-unused-rps-in-assoc-type.stderr
index c7ad1b4e608..ef61fa4be48 100644
--- a/tests/ui/impl-unused-rps-in-assoc-type.stderr
+++ b/tests/ui/impl-unused-rps-in-assoc-type.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a> Fun for Holder {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/implicit-method-bind.stderr b/tests/ui/implicit-method-bind.stderr
index e0a96852720..e9357113f36 100644
--- a/tests/ui/implicit-method-bind.stderr
+++ b/tests/ui/implicit-method-bind.stderr
@@ -9,6 +9,6 @@ help: use parentheses to call the method
 LL |     let _f = 10i32.abs();
    |                       ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/implied-bounds/assoc-ty-wf-used-to-get-assoc-ty.stderr b/tests/ui/implied-bounds/assoc-ty-wf-used-to-get-assoc-ty.stderr
index 307899297bc..92284df41c7 100644
--- a/tests/ui/implied-bounds/assoc-ty-wf-used-to-get-assoc-ty.stderr
+++ b/tests/ui/implied-bounds/assoc-ty-wf-used-to-get-assoc-ty.stderr
@@ -12,6 +12,6 @@ LL |     let _: &'static u8 = test(&x, &&3);
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/implied-bounds/impl-header-unnormalized-types.stderr b/tests/ui/implied-bounds/impl-header-unnormalized-types.stderr
index 88abd5f54c2..07cb0aecda8 100644
--- a/tests/ui/implied-bounds/impl-header-unnormalized-types.stderr
+++ b/tests/ui/implied-bounds/impl-header-unnormalized-types.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL | impl<'a, 'b> NeedsWf<'a, 'b> for Foo<<&'a &'b () as GoodBye>::Forget> {
    |          ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/implied-bounds/impl-implied-bounds-compatibility-unnormalized.stderr b/tests/ui/implied-bounds/impl-implied-bounds-compatibility-unnormalized.stderr
index ebe07027d2f..86b12cf8fa2 100644
--- a/tests/ui/implied-bounds/impl-implied-bounds-compatibility-unnormalized.stderr
+++ b/tests/ui/implied-bounds/impl-implied-bounds-compatibility-unnormalized.stderr
@@ -12,7 +12,7 @@ note: the lint level is defined here
 LL | #![deny(implied_bounds_entailment)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 Future incompatibility report: Future breakage diagnostic:
 error: impl method assumes more implied bounds than the corresponding trait method
diff --git a/tests/ui/implied-bounds/impl-implied-bounds-compatibility.stderr b/tests/ui/implied-bounds/impl-implied-bounds-compatibility.stderr
index 43d3e058ffe..a89645c128b 100644
--- a/tests/ui/implied-bounds/impl-implied-bounds-compatibility.stderr
+++ b/tests/ui/implied-bounds/impl-implied-bounds-compatibility.stderr
@@ -12,7 +12,7 @@ note: the lint level is defined here
 LL | #![deny(implied_bounds_entailment)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 Future incompatibility report: Future breakage diagnostic:
 error: impl method assumes more implied bounds than the corresponding trait method
diff --git a/tests/ui/implied-bounds/issue-100690.stderr b/tests/ui/implied-bounds/issue-100690.stderr
index ac9f7ab2529..49f2fcd0a67 100644
--- a/tests/ui/implied-bounds/issue-100690.stderr
+++ b/tests/ui/implied-bounds/issue-100690.stderr
@@ -17,6 +17,6 @@ LL | fn real_dispatch<T, F>(f: F) -> Result<(), io::Error>
 LL |     F: FnOnce(&mut UIView<T>) -> Result<(), io::Error> + Send + 'static,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `real_dispatch`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/implied-bounds/issue-110161.stderr b/tests/ui/implied-bounds/issue-110161.stderr
index 9e0188694ed..0b736317980 100644
--- a/tests/ui/implied-bounds/issue-110161.stderr
+++ b/tests/ui/implied-bounds/issue-110161.stderr
@@ -7,6 +7,6 @@ LL |     type Ty;
 LL | impl LtTrait for () {
    | ^^^^^^^^^^^^^^^^^^^ missing `Ty` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/implied-bounds/normalization-nested.lifetime.stderr b/tests/ui/implied-bounds/normalization-nested.lifetime.stderr
index 898e5e9511e..abffee57a0f 100644
--- a/tests/ui/implied-bounds/normalization-nested.lifetime.stderr
+++ b/tests/ui/implied-bounds/normalization-nested.lifetime.stderr
@@ -13,6 +13,6 @@ note: `'static` lifetime requirement introduced by this bound
 LL |     I::Item: 'static;
    |              ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0759`.
diff --git a/tests/ui/implied-bounds/references-err.stderr b/tests/ui/implied-bounds/references-err.stderr
index 6076eea3c75..df83fce3bde 100644
--- a/tests/ui/implied-bounds/references-err.stderr
+++ b/tests/ui/implied-bounds/references-err.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `DoesNotExist` in this scope
 LL |     type Assoc = DoesNotExist;
    |                  ^^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/imports/ambiguous-11.stderr b/tests/ui/imports/ambiguous-11.stderr
index 765d6afa8d7..5b7f3059ef4 100644
--- a/tests/ui/imports/ambiguous-11.stderr
+++ b/tests/ui/imports/ambiguous-11.stderr
@@ -18,6 +18,6 @@ LL | use ambiguous_11_extern::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `Error` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/ambiguous-7.stderr b/tests/ui/imports/ambiguous-7.stderr
index 2c6b56c61fd..addc28ff52a 100644
--- a/tests/ui/imports/ambiguous-7.stderr
+++ b/tests/ui/imports/ambiguous-7.stderr
@@ -18,6 +18,6 @@ LL | pub use t2::*;
    |         ^^^^^
    = help: consider adding an explicit import of `Error` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/ambiguous-8.stderr b/tests/ui/imports/ambiguous-8.stderr
index 32056fba69f..11914efe9d8 100644
--- a/tests/ui/imports/ambiguous-8.stderr
+++ b/tests/ui/imports/ambiguous-8.stderr
@@ -18,6 +18,6 @@ LL | use ambiguous_8_extern::*;
    |     ^^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `Error` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/double-import.stderr b/tests/ui/imports/double-import.stderr
index 82f5eb83e6f..73bb73e3490 100644
--- a/tests/ui/imports/double-import.stderr
+++ b/tests/ui/imports/double-import.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use sub2::foo as other_foo;
    |     ~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/extern-crate-used.stderr b/tests/ui/imports/extern-crate-used.stderr
index 1b9a2e4720d..982da0c913e 100644
--- a/tests/ui/imports/extern-crate-used.stderr
+++ b/tests/ui/imports/extern-crate-used.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_extern_crates)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/extern-with-ambiguous-1.stderr b/tests/ui/imports/extern-with-ambiguous-1.stderr
index dca2b4ebee7..ab4aeacbd99 100644
--- a/tests/ui/imports/extern-with-ambiguous-1.stderr
+++ b/tests/ui/imports/extern-with-ambiguous-1.stderr
@@ -18,6 +18,6 @@ LL | use extern_with_ambiguous_1_extern::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `error` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/import-crate-var.stderr b/tests/ui/imports/import-crate-var.stderr
index f1f1dfbdbdb..41a8772d28f 100644
--- a/tests/ui/imports/import-crate-var.stderr
+++ b/tests/ui/imports/import-crate-var.stderr
@@ -6,5 +6,5 @@ LL |     m!();
    |
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/import-from-missing.stderr b/tests/ui/imports/import-from-missing.stderr
index 4254bfb5efb..4020ec1b579 100644
--- a/tests/ui/imports/import-from-missing.stderr
+++ b/tests/ui/imports/import-from-missing.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `spam::eggs`
 LL | use spam::{ham, eggs};
    |                 ^^^^ no `eggs` in `spam`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/import-glob-0.stderr b/tests/ui/imports/import-glob-0.stderr
index 820ff1bb536..6a2837e770d 100644
--- a/tests/ui/imports/import-glob-0.stderr
+++ b/tests/ui/imports/import-glob-0.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `f999` in this scope
 LL |     f999();
    |     ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/imports/import-glob-circular.stderr b/tests/ui/imports/import-glob-circular.stderr
index 86bbea579ae..2eb268813d0 100644
--- a/tests/ui/imports/import-glob-circular.stderr
+++ b/tests/ui/imports/import-glob-circular.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `f1066` in this scope
 LL |     fn test() { f1066(); }
    |                 ^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/imports/import-loop-2.stderr b/tests/ui/imports/import-loop-2.stderr
index 1abfcde03df..1a95200a662 100644
--- a/tests/ui/imports/import-loop-2.stderr
+++ b/tests/ui/imports/import-loop-2.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `a::x`
 LL |     pub use a::x;
    |             ^^^^ no `x` in `a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/import-loop.stderr b/tests/ui/imports/import-loop.stderr
index b87bfb1be52..8ad2d6be4d2 100644
--- a/tests/ui/imports/import-loop.stderr
+++ b/tests/ui/imports/import-loop.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `y::x`
 LL |     pub use y::x;
    |             ^^^^ no `x` in `y`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/import-prefix-macro-1.stderr b/tests/ui/imports/import-prefix-macro-1.stderr
index a6a5b1393da..bdc0e85b43e 100644
--- a/tests/ui/imports/import-prefix-macro-1.stderr
+++ b/tests/ui/imports/import-prefix-macro-1.stderr
@@ -9,5 +9,5 @@ LL | import! { a::b::c }
    |
    = note: this error originates in the macro `import` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/import-prefix-macro-2.stderr b/tests/ui/imports/import-prefix-macro-2.stderr
index 23f8d57645d..070186f2bf2 100644
--- a/tests/ui/imports/import-prefix-macro-2.stderr
+++ b/tests/ui/imports/import-prefix-macro-2.stderr
@@ -9,5 +9,5 @@ LL | import! { a::b::c }
    |
    = note: this error originates in the macro `import` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/import-trait-method.stderr b/tests/ui/imports/import-trait-method.stderr
index 3c26907d3d0..9786eb52d35 100644
--- a/tests/ui/imports/import-trait-method.stderr
+++ b/tests/ui/imports/import-trait-method.stderr
@@ -4,6 +4,6 @@ error[E0253]: `foo` is not directly importable
 LL | use Foo::foo;
    |     ^^^^^^^^ cannot be imported directly
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0253`.
diff --git a/tests/ui/imports/import2.stderr b/tests/ui/imports/import2.stderr
index da888979c30..55eea66fd3b 100644
--- a/tests/ui/imports/import2.stderr
+++ b/tests/ui/imports/import2.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `baz::zed`
 LL | use baz::zed::bar;
    |          ^^^ could not find `zed` in `baz`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/import3.stderr b/tests/ui/imports/import3.stderr
index ca75c9c18bd..80b0a7f0619 100644
--- a/tests/ui/imports/import3.stderr
+++ b/tests/ui/imports/import3.stderr
@@ -6,6 +6,6 @@ LL | use main::bar;
    |
    = help: consider adding `extern crate main` to use the `main` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/import4.stderr b/tests/ui/imports/import4.stderr
index e0b478f1aec..c99e8385118 100644
--- a/tests/ui/imports/import4.stderr
+++ b/tests/ui/imports/import4.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `a::foo`
 LL | mod b { pub use a::foo; }
    |                 ^^^^^^ no `foo` in `a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-109148.stderr b/tests/ui/imports/issue-109148.stderr
index 6cc1221cfe9..b7f1f69dc8f 100644
--- a/tests/ui/imports/issue-109148.stderr
+++ b/tests/ui/imports/issue-109148.stderr
@@ -9,5 +9,5 @@ LL | m!();
    |
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/issue-109343.stderr b/tests/ui/imports/issue-109343.stderr
index 8d9a3aee980..1b95fcf5567 100644
--- a/tests/ui/imports/issue-109343.stderr
+++ b/tests/ui/imports/issue-109343.stderr
@@ -6,6 +6,6 @@ LL | pub use unresolved::f;
    |
    = help: consider adding `extern crate unresolved` to use the `unresolved` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-113953.stderr b/tests/ui/imports/issue-113953.stderr
index 70f91bd3c5b..9daa73a9fe6 100644
--- a/tests/ui/imports/issue-113953.stderr
+++ b/tests/ui/imports/issue-113953.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `unresolved`
 LL | use unresolved as u8;
    |     ^^^^^^^^^^^^^^^^ no external crate `unresolved`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-13404.stderr b/tests/ui/imports/issue-13404.stderr
index 1f50debb07b..a77f399e791 100644
--- a/tests/ui/imports/issue-13404.stderr
+++ b/tests/ui/imports/issue-13404.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `b::f`
 LL | use b::f;
    |     ^^^^ no `f` in `b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-1697.stderr b/tests/ui/imports/issue-1697.stderr
index 019ef9ad56a..840608ca2a1 100644
--- a/tests/ui/imports/issue-1697.stderr
+++ b/tests/ui/imports/issue-1697.stderr
@@ -6,6 +6,6 @@ LL | use unresolved::*;
    |
    = help: consider adding `extern crate unresolved` to use the `unresolved` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-28388-1.stderr b/tests/ui/imports/issue-28388-1.stderr
index 7f5e47aa84f..8256f96c62d 100644
--- a/tests/ui/imports/issue-28388-1.stderr
+++ b/tests/ui/imports/issue-28388-1.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `foo`
 LL | use foo::{};
    |     ^^^^^^^ no `foo` in the root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-28388-2.stderr b/tests/ui/imports/issue-28388-2.stderr
index 1afaf622be7..4eda57dd9e5 100644
--- a/tests/ui/imports/issue-28388-2.stderr
+++ b/tests/ui/imports/issue-28388-2.stderr
@@ -10,6 +10,6 @@ note: the module `n` is defined here
 LL |     mod n {}
    |     ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/imports/issue-2937.stderr b/tests/ui/imports/issue-2937.stderr
index 428634828f9..15622f233fa 100644
--- a/tests/ui/imports/issue-2937.stderr
+++ b/tests/ui/imports/issue-2937.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `m::f`
 LL | use m::f as x;
    |     ^^^^^^^^^ no `f` in `m`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-32354-suggest-import-rename.stderr b/tests/ui/imports/issue-32354-suggest-import-rename.stderr
index 4c5875ba776..de9bdc4f2cc 100644
--- a/tests/ui/imports/issue-32354-suggest-import-rename.stderr
+++ b/tests/ui/imports/issue-32354-suggest-import-rename.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use extension2::ConstructorExtension as OtherConstructorExtension;
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/issue-32833.stderr b/tests/ui/imports/issue-32833.stderr
index 430cc0fda26..332561eca7a 100644
--- a/tests/ui/imports/issue-32833.stderr
+++ b/tests/ui/imports/issue-32833.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `bar::Foo`
 LL | use bar::Foo;
    |     ^^^^^^^^ no `Foo` in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-36881.stderr b/tests/ui/imports/issue-36881.stderr
index 2e1b468603d..e9b632d2718 100644
--- a/tests/ui/imports/issue-36881.stderr
+++ b/tests/ui/imports/issue-36881.stderr
@@ -6,6 +6,6 @@ LL |     use issue_36881_aux::Foo;
    |
    = help: consider adding `extern crate issue_36881_aux` to use the `issue_36881_aux` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-4366.stderr b/tests/ui/imports/issue-4366.stderr
index 4d5b392a7e1..e63399d554e 100644
--- a/tests/ui/imports/issue-4366.stderr
+++ b/tests/ui/imports/issue-4366.stderr
@@ -9,6 +9,6 @@ help: consider importing this function
 LL +         use foo::foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/imports/issue-45799-bad-extern-crate-rename-suggestion-formatting.stderr b/tests/ui/imports/issue-45799-bad-extern-crate-rename-suggestion-formatting.stderr
index 25aca4cb7ec..80cea1a83d9 100644
--- a/tests/ui/imports/issue-45799-bad-extern-crate-rename-suggestion-formatting.stderr
+++ b/tests/ui/imports/issue-45799-bad-extern-crate-rename-suggestion-formatting.stderr
@@ -10,6 +10,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate std as other_std;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/issue-45829/import-twice.stderr b/tests/ui/imports/issue-45829/import-twice.stderr
index 656b011bc3b..b19d5d8f758 100644
--- a/tests/ui/imports/issue-45829/import-twice.stderr
+++ b/tests/ui/imports/issue-45829/import-twice.stderr
@@ -8,6 +8,6 @@ LL | use foo::{A, A};
    |
    = note: `A` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/issue-45829/issue-45829.stderr b/tests/ui/imports/issue-45829/issue-45829.stderr
index e9a9d47ce7c..627a09a07b8 100644
--- a/tests/ui/imports/issue-45829/issue-45829.stderr
+++ b/tests/ui/imports/issue-45829/issue-45829.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use foo::{A, B as OtherA};
    |              ~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/issue-45829/rename-extern-vs-use.stderr b/tests/ui/imports/issue-45829/rename-extern-vs-use.stderr
index 98fd8a623fe..8f2f7bbac0c 100644
--- a/tests/ui/imports/issue-45829/rename-extern-vs-use.stderr
+++ b/tests/ui/imports/issue-45829/rename-extern-vs-use.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate issue_45829_b as other_bar;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0254`.
diff --git a/tests/ui/imports/issue-45829/rename-extern-with-tab.stderr b/tests/ui/imports/issue-45829/rename-extern-with-tab.stderr
index 2c4e8ce996b..ae26d1fd0bb 100644
--- a/tests/ui/imports/issue-45829/rename-extern-with-tab.stderr
+++ b/tests/ui/imports/issue-45829/rename-extern-with-tab.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate issue_45829_b as other_issue_45829_a;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/issue-45829/rename-extern.stderr b/tests/ui/imports/issue-45829/rename-extern.stderr
index 209ae2201f9..46560ef9244 100644
--- a/tests/ui/imports/issue-45829/rename-extern.stderr
+++ b/tests/ui/imports/issue-45829/rename-extern.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate issue_45829_b as other_issue_45829_a;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/issue-45829/rename-use-vs-extern.stderr b/tests/ui/imports/issue-45829/rename-use-vs-extern.stderr
index dfb5810c494..9b0a2534a1d 100644
--- a/tests/ui/imports/issue-45829/rename-use-vs-extern.stderr
+++ b/tests/ui/imports/issue-45829/rename-use-vs-extern.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use std as other_issue_45829_b;
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0254`.
diff --git a/tests/ui/imports/issue-45829/rename-use-with-tabs.stderr b/tests/ui/imports/issue-45829/rename-use-with-tabs.stderr
index 5a63af58855..5751f41ae9d 100644
--- a/tests/ui/imports/issue-45829/rename-use-with-tabs.stderr
+++ b/tests/ui/imports/issue-45829/rename-use-with-tabs.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use foo::{A, bar::B as OtherA};
    |              ~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/issue-45829/rename-with-path.stderr b/tests/ui/imports/issue-45829/rename-with-path.stderr
index 2d26b08384e..69e084db6ff 100644
--- a/tests/ui/imports/issue-45829/rename-with-path.stderr
+++ b/tests/ui/imports/issue-45829/rename-with-path.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use std::{collections::HashMap as A, sync::Arc as OtherA};
    |                                      ~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/issue-45829/rename.stderr b/tests/ui/imports/issue-45829/rename.stderr
index ed185ae2a44..f1ee5112dc1 100644
--- a/tests/ui/imports/issue-45829/rename.stderr
+++ b/tests/ui/imports/issue-45829/rename.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL | use std as other_core;
    |     ~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/imports/issue-47623.stderr b/tests/ui/imports/issue-47623.stderr
index 53968a2960c..be42a4a5b1d 100644
--- a/tests/ui/imports/issue-47623.stderr
+++ b/tests/ui/imports/issue-47623.stderr
@@ -4,6 +4,6 @@ error[E0429]: `self` imports are only allowed within a { } list
 LL | use self;
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0429`.
diff --git a/tests/ui/imports/issue-53512.stderr b/tests/ui/imports/issue-53512.stderr
index 05fe111b38b..6bcba1ad429 100644
--- a/tests/ui/imports/issue-53512.stderr
+++ b/tests/ui/imports/issue-53512.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `m::assert`
 LL | use m::assert;
    |     ^^^^^^^^^ no `assert` in `m`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-55884-1.stderr b/tests/ui/imports/issue-55884-1.stderr
index c38166ddea6..ae8edb04956 100644
--- a/tests/ui/imports/issue-55884-1.stderr
+++ b/tests/ui/imports/issue-55884-1.stderr
@@ -18,6 +18,6 @@ LL |     pub use self::m2::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `S` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/issue-55884-2.stderr b/tests/ui/imports/issue-55884-2.stderr
index 67d4114149a..a409265525b 100644
--- a/tests/ui/imports/issue-55884-2.stderr
+++ b/tests/ui/imports/issue-55884-2.stderr
@@ -25,6 +25,6 @@ note: ...and refers to the struct `ParseOptions` which is defined here
 LL |     pub struct ParseOptions {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^ consider importing it directly
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/imports/issue-57015.stderr b/tests/ui/imports/issue-57015.stderr
index 5374ba3dc9e..f1ae7845241 100644
--- a/tests/ui/imports/issue-57015.stderr
+++ b/tests/ui/imports/issue-57015.stderr
@@ -9,6 +9,6 @@ help: consider importing this module instead
 LL | use glob_ok::something;
    |     ~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-57539.stderr b/tests/ui/imports/issue-57539.stderr
index 88cc42ccf66..c8473cc85bd 100644
--- a/tests/ui/imports/issue-57539.stderr
+++ b/tests/ui/imports/issue-57539.stderr
@@ -15,6 +15,6 @@ LL |     use crate::*;
    = help: consider adding an explicit import of `core` to disambiguate
    = help: or use `self::core` to refer to this module unambiguously
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/issue-81413.stderr b/tests/ui/imports/issue-81413.stderr
index e2dfe02bc85..c2a32125011 100644
--- a/tests/ui/imports/issue-81413.stderr
+++ b/tests/ui/imports/issue-81413.stderr
@@ -6,6 +6,6 @@ LL | pub use doesnt_exist::*;
    |
    = help: consider adding `extern crate doesnt_exist` to use the `doesnt_exist` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-85992.stderr b/tests/ui/imports/issue-85992.stderr
index 810d41009c5..6c75b45d926 100644
--- a/tests/ui/imports/issue-85992.stderr
+++ b/tests/ui/imports/issue-85992.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `crate::issue_85992_extern_2`
 LL | use crate::issue_85992_extern_2;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `issue_85992_extern_2` in the root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-8640.stderr b/tests/ui/imports/issue-8640.stderr
index ab44f067fe7..ea350e97e64 100644
--- a/tests/ui/imports/issue-8640.stderr
+++ b/tests/ui/imports/issue-8640.stderr
@@ -12,6 +12,6 @@ help: you can use `as` to change the binding name of the import
 LL |     use baz::bar as other_bar;
    |         ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/imports/issue-99695-b.stderr b/tests/ui/imports/issue-99695-b.stderr
index b6f5c726a5c..d58d2798746 100644
--- a/tests/ui/imports/issue-99695-b.stderr
+++ b/tests/ui/imports/issue-99695-b.stderr
@@ -11,6 +11,6 @@ LL ~     use ::nu;
 LL ~ pub use self::p::{other_item as _};
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/issue-99695.stderr b/tests/ui/imports/issue-99695.stderr
index 0ef762e1c82..536f51dcb3b 100644
--- a/tests/ui/imports/issue-99695.stderr
+++ b/tests/ui/imports/issue-99695.stderr
@@ -11,6 +11,6 @@ LL ~     use ::nu;
 LL ~ pub use self::{other_item as _};
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/imports/no-std-inject.stderr b/tests/ui/imports/no-std-inject.stderr
index 8e226804890..597ecdce9eb 100644
--- a/tests/ui/imports/no-std-inject.stderr
+++ b/tests/ui/imports/no-std-inject.stderr
@@ -10,6 +10,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate core as other_core;
    | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/overlapping_pub_trait.stderr b/tests/ui/imports/overlapping_pub_trait.stderr
index 490dccd3e80..a82a4101ce0 100644
--- a/tests/ui/imports/overlapping_pub_trait.stderr
+++ b/tests/ui/imports/overlapping_pub_trait.stderr
@@ -15,6 +15,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use overlapping_pub_trait_source::m::Tr;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/imports/resolve-other-libc.stderr b/tests/ui/imports/resolve-other-libc.stderr
index e57b88e50c6..81fe1294671 100644
--- a/tests/ui/imports/resolve-other-libc.stderr
+++ b/tests/ui/imports/resolve-other-libc.stderr
@@ -4,5 +4,5 @@ error: extern location for libc does not exist: test.rlib
 LL | extern crate libc;
    | ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/rfc-1560-warning-cycle.stderr b/tests/ui/imports/rfc-1560-warning-cycle.stderr
index fd7e99165b5..8a83e581383 100644
--- a/tests/ui/imports/rfc-1560-warning-cycle.stderr
+++ b/tests/ui/imports/rfc-1560-warning-cycle.stderr
@@ -18,6 +18,6 @@ LL |         use bar::*;
    |             ^^^^^^
    = help: consider adding an explicit import of `Foo` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/unnamed_pub_trait.stderr b/tests/ui/imports/unnamed_pub_trait.stderr
index 5133273c22f..41772b8e694 100644
--- a/tests/ui/imports/unnamed_pub_trait.stderr
+++ b/tests/ui/imports/unnamed_pub_trait.stderr
@@ -15,6 +15,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use unnamed_pub_trait_source::prelude::*; // trait Tr
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/imports/unused-import-issue-87973.stderr b/tests/ui/imports/unused-import-issue-87973.stderr
index 81b7ea79191..a43e92b1458 100644
--- a/tests/ui/imports/unused-import-issue-87973.stderr
+++ b/tests/ui/imports/unused-import-issue-87973.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_imports)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/unused.stderr b/tests/ui/imports/unused.stderr
index 08128d79425..a76c3c87a47 100644
--- a/tests/ui/imports/unused.stderr
+++ b/tests/ui/imports/unused.stderr
@@ -11,5 +11,5 @@ LL | #![deny(unused)]
    |         ^^^^^^
    = note: `#[deny(unused_imports)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/indexing/index-bot.stderr b/tests/ui/indexing/index-bot.stderr
index bf231c92cad..dca57f3d5b6 100644
--- a/tests/ui/indexing/index-bot.stderr
+++ b/tests/ui/indexing/index-bot.stderr
@@ -4,6 +4,6 @@ error[E0608]: cannot index into a value of type `!`
 LL |     (return)[0];
    |             ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0608`.
diff --git a/tests/ui/indexing/index-help.stderr b/tests/ui/indexing/index-help.stderr
index 2cb212a0139..4ec28ddf871 100644
--- a/tests/ui/indexing/index-help.stderr
+++ b/tests/ui/indexing/index-help.stderr
@@ -9,6 +9,6 @@ LL |     x[0i32];
    = help: for that trait implementation, expected `usize`, found `i32`
    = note: required for `Vec<{integer}>` to implement `Index<i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/indexing/index_message.stderr b/tests/ui/indexing/index_message.stderr
index 80f2bd52314..6affb1ed962 100644
--- a/tests/ui/indexing/index_message.stderr
+++ b/tests/ui/indexing/index_message.stderr
@@ -4,6 +4,6 @@ error[E0608]: cannot index into a value of type `({integer},)`
 LL |     let _ = z[0];
    |              ^^^ help: to access tuple elements, use: `.0`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0608`.
diff --git a/tests/ui/indexing/point-at-index-for-obligation-failure.stderr b/tests/ui/indexing/point-at-index-for-obligation-failure.stderr
index 3e2fbc2ab6f..4cced22789f 100644
--- a/tests/ui/indexing/point-at-index-for-obligation-failure.stderr
+++ b/tests/ui/indexing/point-at-index-for-obligation-failure.stderr
@@ -8,6 +8,6 @@ LL |         &s
    = help: for that trait implementation, expected `str`, found `&str`
    = note: required for `HashMap<String, String>` to implement `Index<&&str>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/inference/ambiguous_type_parameter.stderr b/tests/ui/inference/ambiguous_type_parameter.stderr
index 9cbe221de13..0674deb63ba 100644
--- a/tests/ui/inference/ambiguous_type_parameter.stderr
+++ b/tests/ui/inference/ambiguous_type_parameter.stderr
@@ -9,6 +9,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     <InMemoryStore as Store<String, HashMap<K, String>>>::get_raw(&InMemoryStore, &String::default());
    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/cannot-infer-async.stderr b/tests/ui/inference/cannot-infer-async.stderr
index 0579cf238a9..346109fd5c0 100644
--- a/tests/ui/inference/cannot-infer-async.stderr
+++ b/tests/ui/inference/cannot-infer-async.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |         Ok::<(), E>(())
    |           +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/cannot-infer-closure-circular.stderr b/tests/ui/inference/cannot-infer-closure-circular.stderr
index 98639f307fb..e3cf0cca837 100644
--- a/tests/ui/inference/cannot-infer-closure-circular.stderr
+++ b/tests/ui/inference/cannot-infer-closure-circular.stderr
@@ -12,6 +12,6 @@ help: consider giving this closure parameter an explicit type, where the type fo
 LL |     let x = |r: Result<(), E>| {
    |               +++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/cannot-infer-closure.stderr b/tests/ui/inference/cannot-infer-closure.stderr
index a4b818e6e2b..507a70c1bac 100644
--- a/tests/ui/inference/cannot-infer-closure.stderr
+++ b/tests/ui/inference/cannot-infer-closure.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |         Ok::<(), E>(b)
    |           +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/cannot-infer-partial-try-return.stderr b/tests/ui/inference/cannot-infer-partial-try-return.stderr
index 888c321bc47..ff4d7418a63 100644
--- a/tests/ui/inference/cannot-infer-partial-try-return.stderr
+++ b/tests/ui/inference/cannot-infer-partial-try-return.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |         Ok::<(), QualifiedError<_>>(())
    |           +++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/inference_unstable_featured.stderr b/tests/ui/inference/inference_unstable_featured.stderr
index dc43abf52c6..b908c7142d4 100644
--- a/tests/ui/inference/inference_unstable_featured.stderr
+++ b/tests/ui/inference/inference_unstable_featured.stderr
@@ -15,6 +15,6 @@ help: disambiguate the method for candidate #2
 LL |     assert_eq!(IpuItertools::ipu_flatten(&'x'), 0);
    |                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/inference/inference_unstable_forced.stderr b/tests/ui/inference/inference_unstable_forced.stderr
index a1c4cd851cb..2301eacc596 100644
--- a/tests/ui/inference/inference_unstable_forced.stderr
+++ b/tests/ui/inference/inference_unstable_forced.stderr
@@ -7,6 +7,6 @@ LL |     assert_eq!('x'.ipu_flatten(), 0);
    = note: see issue #99999 <https://github.com/rust-lang/rust/issues/99999> for more information
    = help: add `#![feature(ipu_flatten)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/inference/issue-104649.stderr b/tests/ui/inference/issue-104649.stderr
index 2819329275d..afece960914 100644
--- a/tests/ui/inference/issue-104649.stderr
+++ b/tests/ui/inference/issue-104649.stderr
@@ -9,6 +9,6 @@ help: consider giving `a` an explicit type, where the type for type parameter `E
 LL |     let a: A<std::result::Result<std::result::Result<(), E>, Error>> = A(Result::Ok(Result::Ok(())));
    |          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/issue-113354.stderr b/tests/ui/inference/issue-113354.stderr
index 045a5aa7bf0..27cc7a33238 100644
--- a/tests/ui/inference/issue-113354.stderr
+++ b/tests/ui/inference/issue-113354.stderr
@@ -9,6 +9,6 @@ help: consider adding `let`
 LL |     let _ = || { while let Some(_) = Some(1) { } };
    |                        +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/inference/issue-70082.stderr b/tests/ui/inference/issue-70082.stderr
index 47229a5fee1..442e7479a9e 100644
--- a/tests/ui/inference/issue-70082.stderr
+++ b/tests/ui/inference/issue-70082.stderr
@@ -12,6 +12,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     let y: f64 = 0.01f64 * <i16 as Into<T>>::into(1i16);
    |                            +++++++++++++++++++++++    ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/inference/issue-71309.stderr b/tests/ui/inference/issue-71309.stderr
index af8714f1c80..673649c767e 100644
--- a/tests/ui/inference/issue-71309.stderr
+++ b/tests/ui/inference/issue-71309.stderr
@@ -10,6 +10,6 @@ help: you can convert an `i32` to a `u32` and panic if the converted value doesn
 LL |     let y: u32 = x?.try_into().unwrap();
    |                    ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/inference/issue-71584.stderr b/tests/ui/inference/issue-71584.stderr
index 22c0f113d6a..391d3e7613e 100644
--- a/tests/ui/inference/issue-71584.stderr
+++ b/tests/ui/inference/issue-71584.stderr
@@ -12,6 +12,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     d = d % <u32 as Into<T>>::into(n);
    |             +++++++++++++++++++++++ ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/inference/issue-71732.stderr b/tests/ui/inference/issue-71732.stderr
index e89e4dca619..af8b310fd1d 100644
--- a/tests/ui/inference/issue-71732.stderr
+++ b/tests/ui/inference/issue-71732.stderr
@@ -17,6 +17,6 @@ help: consider specifying the generic argument
 LL |         .get::<Q>(&"key".into())
    |             +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/issue-80816.stderr b/tests/ui/inference/issue-80816.stderr
index 80c0c8abec6..ab62db8e6af 100644
--- a/tests/ui/inference/issue-80816.stderr
+++ b/tests/ui/inference/issue-80816.stderr
@@ -24,6 +24,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     let guard: Guard<Arc<usize>> = <Arc<ArcSwapAny<Arc<usize>>> as Access<T>>::load(&s);
    |                                    ++++++++++++++++++++++++++++++++++++++++++++++++++ ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/issue-83606.stderr b/tests/ui/inference/issue-83606.stderr
index 97ed53fb3ce..00de4029e42 100644
--- a/tests/ui/inference/issue-83606.stderr
+++ b/tests/ui/inference/issue-83606.stderr
@@ -9,6 +9,6 @@ help: consider giving this pattern a type, where the value of const parameter `N
 LL |     let _: [usize; N] = foo("foo");
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/issue-86162-1.stderr b/tests/ui/inference/issue-86162-1.stderr
index 4f621b82dc5..fe3cee77160 100644
--- a/tests/ui/inference/issue-86162-1.stderr
+++ b/tests/ui/inference/issue-86162-1.stderr
@@ -17,6 +17,6 @@ help: consider specifying the generic argument
 LL |     foo(gen::<T>()); //<- Do not suggest `foo::<impl Clone>()`!
    |            +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/issue-86162-2.stderr b/tests/ui/inference/issue-86162-2.stderr
index 9aff2cec160..7b45b196629 100644
--- a/tests/ui/inference/issue-86162-2.stderr
+++ b/tests/ui/inference/issue-86162-2.stderr
@@ -17,6 +17,6 @@ help: consider specifying the generic argument
 LL |     Foo::bar(gen::<T>()); //<- Do not suggest `Foo::bar::<impl Clone>()`!
    |                 +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/multiple-impl-apply.stderr b/tests/ui/inference/multiple-impl-apply.stderr
index ec49e15201a..1a81955e1e8 100644
--- a/tests/ui/inference/multiple-impl-apply.stderr
+++ b/tests/ui/inference/multiple-impl-apply.stderr
@@ -18,6 +18,6 @@ help: consider giving `y` an explicit type
 LL |     let y: /* Type */ = x.into();
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/need_type_info/concrete-impl.stderr b/tests/ui/inference/need_type_info/concrete-impl.stderr
index 6b86753caf9..7b400fd17db 100644
--- a/tests/ui/inference/need_type_info/concrete-impl.stderr
+++ b/tests/ui/inference/need_type_info/concrete-impl.stderr
@@ -13,6 +13,6 @@ LL |
 LL | impl Ambiguous<Two> for Struct {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/need_type_info/do-not-suggest-generic-arguments-for-turbofish.stderr b/tests/ui/inference/need_type_info/do-not-suggest-generic-arguments-for-turbofish.stderr
index 2ad35ab039f..fcac537a9b8 100644
--- a/tests/ui/inference/need_type_info/do-not-suggest-generic-arguments-for-turbofish.stderr
+++ b/tests/ui/inference/need_type_info/do-not-suggest-generic-arguments-for-turbofish.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     OhNo::C::<u32, _>;
    |     ^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `U` declared on the enum `OhNo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/expr-struct-type-relative-enum.stderr b/tests/ui/inference/need_type_info/expr-struct-type-relative-enum.stderr
index 68ecb381348..dfbdc3266c5 100644
--- a/tests/ui/inference/need_type_info/expr-struct-type-relative-enum.stderr
+++ b/tests/ui/inference/need_type_info/expr-struct-type-relative-enum.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |         needs_infer::<T>();
    |                    +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/expr-struct-type-relative-gat.stderr b/tests/ui/inference/need_type_info/expr-struct-type-relative-gat.stderr
index cbc2477deb3..c72529f71c2 100644
--- a/tests/ui/inference/need_type_info/expr-struct-type-relative-gat.stderr
+++ b/tests/ui/inference/need_type_info/expr-struct-type-relative-gat.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |         Self::Output::Simple {};
    |         ^^^^^^^^^^^^ cannot infer type for type parameter `T` declared on the associated type `Output`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/expr-struct-type-relative.stderr b/tests/ui/inference/need_type_info/expr-struct-type-relative.stderr
index 397d8e7be04..333c93859b5 100644
--- a/tests/ui/inference/need_type_info/expr-struct-type-relative.stderr
+++ b/tests/ui/inference/need_type_info/expr-struct-type-relative.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |         needs_infer::<T>();
    |                    +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/infer-var-for-self-param.stderr b/tests/ui/inference/need_type_info/infer-var-for-self-param.stderr
index 36d75469392..aeebf68e675 100644
--- a/tests/ui/inference/need_type_info/infer-var-for-self-param.stderr
+++ b/tests/ui/inference/need_type_info/infer-var-for-self-param.stderr
@@ -9,6 +9,6 @@ help: use a fully-qualified path to a specific available implementation
 LL |     let _ = (</* self type */ as Default>::default(),);
    |              +++++++++++++++++++        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/inference/need_type_info/issue-103053.stderr b/tests/ui/inference/need_type_info/issue-103053.stderr
index 84f0475d8cd..ed389393abc 100644
--- a/tests/ui/inference/need_type_info/issue-103053.stderr
+++ b/tests/ui/inference/need_type_info/issue-103053.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     None::<T>;
    |         +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
index 464655bbcf4..3de317d2af6 100644
--- a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
+++ b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
@@ -6,6 +6,6 @@ LL |     println!("{:?}", []);
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr b/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr
index 9ca94cd58df..455304524ed 100644
--- a/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr
+++ b/tests/ui/inference/need_type_info/issue-113264-incorrect-impl-trait-in-path-suggestion.stderr
@@ -17,6 +17,6 @@ help: consider specifying the generic argument
 LL |     (S {}).owo(None::<&_>)
    |                    ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/inference/need_type_info/self-ty-in-path.stderr b/tests/ui/inference/need_type_info/self-ty-in-path.stderr
index 04b521dbdb3..d651927788e 100644
--- a/tests/ui/inference/need_type_info/self-ty-in-path.stderr
+++ b/tests/ui/inference/need_type_info/self-ty-in-path.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |         Self::func_a::<U>();
    |                     +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/need_type_info/type-alias-indirect.stderr b/tests/ui/inference/need_type_info/type-alias-indirect.stderr
index 6161690df50..535c0044aec 100644
--- a/tests/ui/inference/need_type_info/type-alias-indirect.stderr
+++ b/tests/ui/inference/need_type_info/type-alias-indirect.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     IndirectAlias::new();
    |     ^^^^^^^^^^^^^ cannot infer type for type parameter `T` declared on the type alias `IndirectAlias`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/inference/question-mark-type-infer.stderr b/tests/ui/inference/question-mark-type-infer.stderr
index 52baa213302..45303a2c87f 100644
--- a/tests/ui/inference/question-mark-type-infer.stderr
+++ b/tests/ui/inference/question-mark-type-infer.stderr
@@ -12,6 +12,6 @@ help: consider specifying the generic argument
 LL |     l.iter().map(f).collect::<Vec<_>>()?
    |                            ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/infinite/infinite-alias.stderr b/tests/ui/infinite/infinite-alias.stderr
index 9d9265f8c36..3862c1139c5 100644
--- a/tests/ui/infinite/infinite-alias.stderr
+++ b/tests/ui/infinite/infinite-alias.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | struct Rec(Box<Wrapper<Rec>>);
    |            ++++            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/infinite/infinite-instantiation.stderr b/tests/ui/infinite/infinite-instantiation.stderr
index 951e0f5870d..43d267fa46b 100644
--- a/tests/ui/infinite/infinite-instantiation.stderr
+++ b/tests/ui/infinite/infinite-instantiation.stderr
@@ -11,5 +11,5 @@ LL | fn function<T:ToOpt + Clone>(counter: usize, t: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/infinite/infinite-instantiation/infinite-instantiation.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/infinite/infinite-macro-expansion.stderr b/tests/ui/infinite/infinite-macro-expansion.stderr
index 15654dfaf88..08fb4fa7723 100644
--- a/tests/ui/infinite/infinite-macro-expansion.stderr
+++ b/tests/ui/infinite/infinite-macro-expansion.stderr
@@ -10,5 +10,5 @@ LL |     recursive!()
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`infinite_macro_expansion`)
    = note: this error originates in the macro `recursive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/infinite/infinite-recursion-const-fn.stderr b/tests/ui/infinite/infinite-recursion-const-fn.stderr
index 53b603a47b5..fd5a3c3c546 100644
--- a/tests/ui/infinite/infinite-recursion-const-fn.stderr
+++ b/tests/ui/infinite/infinite-recursion-const-fn.stderr
@@ -645,6 +645,6 @@ note: inside `ARR::{constant#0}`
 LL | const ARR: [i32; a()] = [5; 6];
    |                  ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/infinite/infinite-tag-type-recursion.stderr b/tests/ui/infinite/infinite-tag-type-recursion.stderr
index 513bbfc1b8c..4ca408260b8 100644
--- a/tests/ui/infinite/infinite-tag-type-recursion.stderr
+++ b/tests/ui/infinite/infinite-tag-type-recursion.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | enum MList { Cons(isize, Box<MList>), Nil }
    |                          ++++     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/infinite/infinite-trait-alias-recursion.stderr b/tests/ui/infinite/infinite-trait-alias-recursion.stderr
index 39d7aa4c16a..220d81031ac 100644
--- a/tests/ui/infinite/infinite-trait-alias-recursion.stderr
+++ b/tests/ui/infinite/infinite-trait-alias-recursion.stderr
@@ -23,6 +23,6 @@ LL | trait T1 = T2;
    | ^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated.stderr b/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated.stderr
index ec63688fa8b..57ca1b24d2a 100644
--- a/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated.stderr
+++ b/tests/ui/infinite/infinite-type-alias-mutual-recursion.gated.stderr
@@ -31,6 +31,6 @@ LL | | fn main() {}
    | |____________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/infinite/infinite-vec-type-recursion.feature.stderr b/tests/ui/infinite/infinite-vec-type-recursion.feature.stderr
index 3a146215905..3aac0d7d1db 100644
--- a/tests/ui/infinite/infinite-vec-type-recursion.feature.stderr
+++ b/tests/ui/infinite/infinite-vec-type-recursion.feature.stderr
@@ -6,6 +6,6 @@ LL | type X = Vec<X>;
    |
    = note: in case this is a recursive type alias, consider using a struct, enum, or union instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/infinite/infinite-vec-type-recursion.gated.stderr b/tests/ui/infinite/infinite-vec-type-recursion.gated.stderr
index e47d9b652fb..efafc9b75cd 100644
--- a/tests/ui/infinite/infinite-vec-type-recursion.gated.stderr
+++ b/tests/ui/infinite/infinite-vec-type-recursion.gated.stderr
@@ -21,6 +21,6 @@ LL | | fn main() { let b: X = Vec::new(); }
    | |____________________________________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/inline-const/const-expr-generic-err2.stderr b/tests/ui/inline-const/const-expr-generic-err2.stderr
index 00b716cd259..5876a6c9e19 100644
--- a/tests/ui/inline-const/const-expr-generic-err2.stderr
+++ b/tests/ui/inline-const/const-expr-generic-err2.stderr
@@ -6,5 +6,5 @@ LL |     let _ = [0u8; const { std::mem::size_of::<T>() }];
    |
    = note: this may fail depending on what value the parameter takes
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/inline-const/const-expr-lifetime-err.stderr b/tests/ui/inline-const/const-expr-lifetime-err.stderr
index 443fcf89c4e..75877bc093a 100644
--- a/tests/ui/inline-const/const-expr-lifetime-err.stderr
+++ b/tests/ui/inline-const/const-expr-lifetime-err.stderr
@@ -14,6 +14,6 @@ LL |
 LL | }
    | - `y` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/inline-const/expr-unsafe-err.mir.stderr b/tests/ui/inline-const/expr-unsafe-err.mir.stderr
index 1bec41e2efa..ebd18f89d9c 100644
--- a/tests/ui/inline-const/expr-unsafe-err.mir.stderr
+++ b/tests/ui/inline-const/expr-unsafe-err.mir.stderr
@@ -6,6 +6,6 @@ LL |         require_unsafe();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/inline-const/expr-unsafe-err.thir.stderr b/tests/ui/inline-const/expr-unsafe-err.thir.stderr
index c971e8afb35..45f850d1f99 100644
--- a/tests/ui/inline-const/expr-unsafe-err.thir.stderr
+++ b/tests/ui/inline-const/expr-unsafe-err.thir.stderr
@@ -6,6 +6,6 @@ LL |         require_unsafe();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/inline-const/expr-with-block-err.stderr b/tests/ui/inline-const/expr-with-block-err.stderr
index 6f7408f4e2a..a46d7395045 100644
--- a/tests/ui/inline-const/expr-with-block-err.stderr
+++ b/tests/ui/inline-const/expr-with-block-err.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     const { 2 } - const { 1 };
    |             ^ expected `()`, found integer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/inline-const/pat-match-fndef.stderr b/tests/ui/inline-const/pat-match-fndef.stderr
index c94782b17ce..02c4a60b68f 100644
--- a/tests/ui/inline-const/pat-match-fndef.stderr
+++ b/tests/ui/inline-const/pat-match-fndef.stderr
@@ -13,5 +13,5 @@ error: `fn() {uwu}` cannot be used in patterns
 LL |         const { uwu } => {}
    |         ^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/inline-const/promotion.stderr b/tests/ui/inline-const/promotion.stderr
index 795fc8f5921..7f06b97818b 100644
--- a/tests/ui/inline-const/promotion.stderr
+++ b/tests/ui/inline-const/promotion.stderr
@@ -9,6 +9,6 @@ LL |
 LL |         }
    |         - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/inline-const/required-const.stderr b/tests/ui/inline-const/required-const.stderr
index d6948e7acc0..cd86020184d 100644
--- a/tests/ui/inline-const/required-const.stderr
+++ b/tests/ui/inline-const/required-const.stderr
@@ -6,6 +6,6 @@ LL |         const { panic!() }
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/inline-disallow-on-variant.stderr b/tests/ui/inline-disallow-on-variant.stderr
index 1b176579bbb..255f6bc6a19 100644
--- a/tests/ui/inline-disallow-on-variant.stderr
+++ b/tests/ui/inline-disallow-on-variant.stderr
@@ -7,6 +7,6 @@ LL |
 LL |     Variant,
    |     ------- not a function or closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0518`.
diff --git a/tests/ui/instrument-xray/target-not-supported.stderr b/tests/ui/instrument-xray/target-not-supported.stderr
index 6e3b0c8a380..119094bfc4c 100644
--- a/tests/ui/instrument-xray/target-not-supported.stderr
+++ b/tests/ui/instrument-xray/target-not-supported.stderr
@@ -1,4 +1,4 @@
 error: XRay instrumentation is not supported for this target
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/integral-variable-unification-error.stderr b/tests/ui/integral-variable-unification-error.stderr
index f77c265a2ad..1caa6042fd2 100644
--- a/tests/ui/integral-variable-unification-error.stderr
+++ b/tests/ui/integral-variable-unification-error.stderr
@@ -9,6 +9,6 @@ LL |         2;
 LL |     x = 5.0;
    |         ^^^ expected integer, found floating-point number
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/interior-mutability/interior-mutability.stderr b/tests/ui/interior-mutability/interior-mutability.stderr
index 0c3be7ca607..36686565e2e 100644
--- a/tests/ui/interior-mutability/interior-mutability.stderr
+++ b/tests/ui/interior-mutability/interior-mutability.stderr
@@ -18,6 +18,6 @@ LL |     catch_unwind(|| { x.set(23); });
 note: required by a bound in `catch_unwind`
   --> $SRC_DIR/std/src/panic.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/internal-lints/existing_doc_keyword.stderr b/tests/ui/internal-lints/existing_doc_keyword.stderr
index 5110b9be08a..8f519fe6b5f 100644
--- a/tests/ui/internal-lints/existing_doc_keyword.stderr
+++ b/tests/ui/internal-lints/existing_doc_keyword.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(rustc::existing_doc_keyword)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/internal/internal-unstable-const.stderr b/tests/ui/internal/internal-unstable-const.stderr
index 5c63992d819..ed9196d2b63 100644
--- a/tests/ui/internal/internal-unstable-const.stderr
+++ b/tests/ui/internal/internal-unstable-const.stderr
@@ -15,5 +15,5 @@ LL + #[rustc_allow_const_fn_unstable(const_fn_floating_point_arithmetic)]
 LL | pub const fn foo() -> f32 {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/internal/internal-unstable-thread-local.stderr b/tests/ui/internal/internal-unstable-thread-local.stderr
index 558e3dbb78d..7c07c762827 100644
--- a/tests/ui/internal/internal-unstable-thread-local.stderr
+++ b/tests/ui/internal/internal-unstable-thread-local.stderr
@@ -6,6 +6,6 @@ LL | thread_local!(static BAR: () = internal_unstable::unstable());
    |
    = help: add `#![feature(function)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/intrinsics/const-eval-select-stability.stderr b/tests/ui/intrinsics/const-eval-select-stability.stderr
index 65b507b887b..335b9877aa0 100644
--- a/tests/ui/intrinsics/const-eval-select-stability.stderr
+++ b/tests/ui/intrinsics/const-eval-select-stability.stderr
@@ -6,5 +6,5 @@ LL |     const_eval_select((), nothing, log);
    |
    = help: const-stable functions can only call other const-stable functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/intrinsics/issue-28575.mir.stderr b/tests/ui/intrinsics/issue-28575.mir.stderr
index c42498390c7..4b29b4c1b6a 100644
--- a/tests/ui/intrinsics/issue-28575.mir.stderr
+++ b/tests/ui/intrinsics/issue-28575.mir.stderr
@@ -6,6 +6,6 @@ LL |     FOO()
    |
    = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/intrinsics/issue-28575.thir.stderr b/tests/ui/intrinsics/issue-28575.thir.stderr
index c42498390c7..4b29b4c1b6a 100644
--- a/tests/ui/intrinsics/issue-28575.thir.stderr
+++ b/tests/ui/intrinsics/issue-28575.thir.stderr
@@ -6,6 +6,6 @@ LL |     FOO()
    |
    = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADTARGET.stderr b/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADTARGET.stderr
index 52a59190264..7bc17c5c68c 100644
--- a/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADTARGET.stderr
+++ b/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADTARGET.stderr
@@ -1,4 +1,4 @@
 error: `-Zbranch-protection` is only supported on aarch64
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid-compile-flags/invalid-llvm-passes.stderr b/tests/ui/invalid-compile-flags/invalid-llvm-passes.stderr
index ae1f85e41e4..bbacf3f46cf 100644
--- a/tests/ui/invalid-compile-flags/invalid-llvm-passes.stderr
+++ b/tests/ui/invalid-compile-flags/invalid-llvm-passes.stderr
@@ -1,4 +1,4 @@
 error: failed to run LLVM passes: unknown pass name 'unknown-pass'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid-module-declaration/invalid-module-declaration.stderr b/tests/ui/invalid-module-declaration/invalid-module-declaration.stderr
index 08aec25928c..a8f65883d63 100644
--- a/tests/ui/invalid-module-declaration/invalid-module-declaration.stderr
+++ b/tests/ui/invalid-module-declaration/invalid-module-declaration.stderr
@@ -7,6 +7,6 @@ LL | pub mod baz;
    = help: to create the module `baz`, create file "$DIR/auxiliary/foo/bar/baz.rs" or "$DIR/auxiliary/foo/bar/baz/mod.rs"
    = note: if there is a `mod baz` elsewhere in the crate already, import it with `use crate::...` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0583`.
diff --git a/tests/ui/invalid-self-argument/bare-fn-start.stderr b/tests/ui/invalid-self-argument/bare-fn-start.stderr
index 37753e61f58..bf7160bcd2d 100644
--- a/tests/ui/invalid-self-argument/bare-fn-start.stderr
+++ b/tests/ui/invalid-self-argument/bare-fn-start.stderr
@@ -6,5 +6,5 @@ LL | fn a(&self) { }
    |
    = note: associated functions are those in `impl` or `trait` definitions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid-self-argument/bare-fn.stderr b/tests/ui/invalid-self-argument/bare-fn.stderr
index ff2217b5e80..7abb56602d4 100644
--- a/tests/ui/invalid-self-argument/bare-fn.stderr
+++ b/tests/ui/invalid-self-argument/bare-fn.stderr
@@ -4,5 +4,5 @@ error: unexpected `self` parameter in function
 LL | fn b(foo: u32, &mut self) { }
    |                ^^^^^^^^^ must be the first parameter of an associated function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid-self-argument/trait-fn.stderr b/tests/ui/invalid-self-argument/trait-fn.stderr
index b9887af962c..c9d0a338ef4 100644
--- a/tests/ui/invalid-self-argument/trait-fn.stderr
+++ b/tests/ui/invalid-self-argument/trait-fn.stderr
@@ -4,5 +4,5 @@ error: unexpected `self` parameter in function
 LL |     fn c(foo: u32, self) {}
    |                    ^^^^ must be the first parameter of an associated function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid/invalid-crate-type-macro.stderr b/tests/ui/invalid/invalid-crate-type-macro.stderr
index c196d4278a2..1cf77d4086b 100644
--- a/tests/ui/invalid/invalid-crate-type-macro.stderr
+++ b/tests/ui/invalid/invalid-crate-type-macro.stderr
@@ -4,5 +4,5 @@ error: malformed `crate_type` attribute input
 LL | #![crate_type = foo!()]
    | ^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![crate_type = "bin|lib|..."]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr b/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
index c8a4d681379..1df34532533 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
+++ b/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
@@ -4,5 +4,5 @@ error: attribute should be applied to a module
 LL | #[debugger_visualizer(natvis_file = "./foo.natvis.xml")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid/invalid-macro-matcher.stderr b/tests/ui/invalid/invalid-macro-matcher.stderr
index dbe025b7330..f85adc10cac 100644
--- a/tests/ui/invalid/invalid-macro-matcher.stderr
+++ b/tests/ui/invalid/invalid-macro-matcher.stderr
@@ -4,5 +4,5 @@ error: invalid macro matcher; matchers must be contained in balanced delimiters
 LL |     _ => ();
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid/invalid-no-sanitize.stderr b/tests/ui/invalid/invalid-no-sanitize.stderr
index 4600034952b..b1c80438b31 100644
--- a/tests/ui/invalid/invalid-no-sanitize.stderr
+++ b/tests/ui/invalid/invalid-no-sanitize.stderr
@@ -6,5 +6,5 @@ LL | #[no_sanitize(brontosaurus)]
    |
    = note: expected one of: `address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow-call-stack`, or `thread`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid/invalid-path-in-const.stderr b/tests/ui/invalid/invalid-path-in-const.stderr
index a14ab7d85e8..31528ab856e 100644
--- a/tests/ui/invalid/invalid-path-in-const.stderr
+++ b/tests/ui/invalid/invalid-path-in-const.stderr
@@ -4,6 +4,6 @@ error[E0599]: no associated item named `DOESNOTEXIST` found for type `u32` in th
 LL |     fn f(a: [u8; u32::DOESNOTEXIST]) {}
    |                       ^^^^^^^^^^^^ associated item not found in `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/invalid_crate_type_syntax.stderr b/tests/ui/invalid_crate_type_syntax.stderr
index 4072a2fa162..a5563720f62 100644
--- a/tests/ui/invalid_crate_type_syntax.stderr
+++ b/tests/ui/invalid_crate_type_syntax.stderr
@@ -4,5 +4,5 @@ error: malformed `crate_type` attribute input
 LL | #![crate_type(lib)]
    | ^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![crate_type = "bin|lib|..."]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/io-checks/non-ice-error-on-worker-io-fail.stderr b/tests/ui/io-checks/non-ice-error-on-worker-io-fail.stderr
index f1d9ed8ac8b..5775a4032c3 100644
--- a/tests/ui/io-checks/non-ice-error-on-worker-io-fail.stderr
+++ b/tests/ui/io-checks/non-ice-error-on-worker-io-fail.stderr
@@ -2,5 +2,5 @@ warning: ignoring --out-dir flag due to -o flag
 
 error: io error modifying ./does-not-exist/
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/issues/issue-10291.stderr b/tests/ui/issues/issue-10291.stderr
index a7b827d27a8..68ed9a0de5d 100644
--- a/tests/ui/issues/issue-10291.stderr
+++ b/tests/ui/issues/issue-10291.stderr
@@ -7,5 +7,5 @@ LL |     drop::<Box<dyn for<'z> FnMut(&'z isize) -> &'z isize>>(Box::new(|z| {
 LL |         x
    |         ^ returning this value requires that `'x` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-102964.stderr b/tests/ui/issues/issue-102964.stderr
index c0766480a41..0e2761f3f57 100644
--- a/tests/ui/issues/issue-102964.stderr
+++ b/tests/ui/issues/issue-102964.stderr
@@ -14,6 +14,6 @@ LL ~     let rc = Rc::new(function);
 LL +     rc
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-10465.stderr b/tests/ui/issues/issue-10465.stderr
index 1b7b9d5909e..c6bc0786af1 100644
--- a/tests/ui/issues/issue-10465.stderr
+++ b/tests/ui/issues/issue-10465.stderr
@@ -10,6 +10,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL +         use a::A;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-10545.stderr b/tests/ui/issues/issue-10545.stderr
index f1da33eaba1..9aa04217174 100644
--- a/tests/ui/issues/issue-10545.stderr
+++ b/tests/ui/issues/issue-10545.stderr
@@ -10,6 +10,6 @@ note: the struct `S` is defined here
 LL |     struct S;
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/issues/issue-10656.stderr b/tests/ui/issues/issue-10656.stderr
index 2e4365f1ed7..61828f9c02a 100644
--- a/tests/ui/issues/issue-10656.stderr
+++ b/tests/ui/issues/issue-10656.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(missing_docs)]
    |         ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-10764.stderr b/tests/ui/issues/issue-10764.stderr
index 4d8a85a1397..f3bd0100a72 100644
--- a/tests/ui/issues/issue-10764.stderr
+++ b/tests/ui/issues/issue-10764.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn f(_: extern "Rust" fn()) {}
    |    ^ ---------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-11192.stderr b/tests/ui/issues/issue-11192.stderr
index fc154801340..a8a18c49549 100644
--- a/tests/ui/issues/issue-11192.stderr
+++ b/tests/ui/issues/issue-11192.stderr
@@ -12,6 +12,6 @@ LL |     test(&*ptr);
    |     |
    |     mutable borrow later used by call
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/issues/issue-11374.stderr b/tests/ui/issues/issue-11374.stderr
index 879dc5b76c5..275a0e6b5d7 100644
--- a/tests/ui/issues/issue-11374.stderr
+++ b/tests/ui/issues/issue-11374.stderr
@@ -18,6 +18,6 @@ help: consider mutably borrowing here
 LL |     c.read_to(&mut v);
    |               ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-11593.stderr b/tests/ui/issues/issue-11593.stderr
index aa9768b1885..8262bc9321a 100644
--- a/tests/ui/issues/issue-11593.stderr
+++ b/tests/ui/issues/issue-11593.stderr
@@ -10,6 +10,6 @@ note: the trait `Foo` is defined here
 LL | trait Foo {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/issues/issue-11681.stderr b/tests/ui/issues/issue-11681.stderr
index f2f93076671..4f23ba86eec 100644
--- a/tests/ui/issues/issue-11681.stderr
+++ b/tests/ui/issues/issue-11681.stderr
@@ -6,6 +6,6 @@ LL |   let testValue = &Test;
 LL |   return testValue;
    |          ^^^^^^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/issues/issue-11692-1.stderr b/tests/ui/issues/issue-11692-1.stderr
index 386463436b8..46382f65218 100644
--- a/tests/ui/issues/issue-11692-1.stderr
+++ b/tests/ui/issues/issue-11692-1.stderr
@@ -4,5 +4,5 @@ error: cannot find macro `testo` in this scope
 LL |     print!(testo!());
    |            ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-11692-2.stderr b/tests/ui/issues/issue-11692-2.stderr
index 84746ca2c88..53add509ca5 100644
--- a/tests/ui/issues/issue-11692-2.stderr
+++ b/tests/ui/issues/issue-11692-2.stderr
@@ -6,5 +6,5 @@ LL |     concat!(test!());
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-11844.stderr b/tests/ui/issues/issue-11844.stderr
index 9afd209773b..9ff66eaef49 100644
--- a/tests/ui/issues/issue-11844.stderr
+++ b/tests/ui/issues/issue-11844.stderr
@@ -9,6 +9,6 @@ LL |         Ok(a) =>
    = note: expected enum `Option<Box<{integer}>>`
               found enum `Result<_, _>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-12028.stderr b/tests/ui/issues/issue-12028.stderr
index 8d6b81c24b6..3d7fb13d447 100644
--- a/tests/ui/issues/issue-12028.stderr
+++ b/tests/ui/issues/issue-12028.stderr
@@ -10,6 +10,6 @@ help: try using a fully qualified path to specify the expected types
 LL |         <u8 as StreamHash<H>>::input_stream(self, &mut stream);
    |         ++++++++++++++++++++++++++++++++++++    ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/issues/issue-12041.stderr b/tests/ui/issues/issue-12041.stderr
index b9ffa499afe..51061c0262e 100644
--- a/tests/ui/issues/issue-12041.stderr
+++ b/tests/ui/issues/issue-12041.stderr
@@ -6,6 +6,6 @@ LL |             let tx = tx;
    |
    = note: move occurs because `tx` has type `Sender<i32>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/issues/issue-12127.stderr b/tests/ui/issues/issue-12127.stderr
index 2e585867941..2a6233547ee 100644
--- a/tests/ui/issues/issue-12127.stderr
+++ b/tests/ui/issues/issue-12127.stderr
@@ -13,6 +13,6 @@ LL |         f();
    |         ^
    = note: move occurs because `f` has type `{closure@$DIR/issue-12127.rs:8:24: 8:30}`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/issues/issue-12187-1.stderr b/tests/ui/issues/issue-12187-1.stderr
index d2a6a96082e..93dc1df8f63 100644
--- a/tests/ui/issues/issue-12187-1.stderr
+++ b/tests/ui/issues/issue-12187-1.stderr
@@ -9,6 +9,6 @@ help: consider giving this pattern a type, where the type for type parameter `T`
 LL |     let &v: &T = new();
    |           ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-12187-2.stderr b/tests/ui/issues/issue-12187-2.stderr
index ac75ebb4256..e9ba52ff4fd 100644
--- a/tests/ui/issues/issue-12187-2.stderr
+++ b/tests/ui/issues/issue-12187-2.stderr
@@ -9,6 +9,6 @@ help: consider giving this pattern a type, where the type for type parameter `T`
 LL |     let &v: &T = new();
    |           ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-12863.stderr b/tests/ui/issues/issue-12863.stderr
index 9c29a37cb93..95d4a704e72 100644
--- a/tests/ui/issues/issue-12863.stderr
+++ b/tests/ui/issues/issue-12863.stderr
@@ -4,6 +4,6 @@ error[E0532]: expected unit struct, unit variant or constant, found function `fo
 LL |         foo::bar => {}
    |         ^^^^^^^^ not a unit struct, unit variant or constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/issues/issue-13058.stderr b/tests/ui/issues/issue-13058.stderr
index 8368978deab..7cc2860eb50 100644
--- a/tests/ui/issues/issue-13058.stderr
+++ b/tests/ui/issues/issue-13058.stderr
@@ -7,6 +7,6 @@ LL | {
 LL |     let cont_iter = cont.iter();
    |                     ^^^^^^^^^^^ lifetime `'r` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/issues/issue-13446.stderr b/tests/ui/issues/issue-13446.stderr
index 139c34c8880..28c459e6e62 100644
--- a/tests/ui/issues/issue-13446.stderr
+++ b/tests/ui/issues/issue-13446.stderr
@@ -8,6 +8,6 @@ LL | static VEC: [u32; 256] = vec![];
              found struct `Vec<_>`
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-13482-2.stderr b/tests/ui/issues/issue-13482-2.stderr
index ccab95878b5..87a6782a5e6 100644
--- a/tests/ui/issues/issue-13482-2.stderr
+++ b/tests/ui/issues/issue-13482-2.stderr
@@ -4,6 +4,6 @@ error[E0527]: pattern requires 0 elements but array has 2
 LL |         [] => None,
    |         ^^ expected 2 elements
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0527`.
diff --git a/tests/ui/issues/issue-13482.stderr b/tests/ui/issues/issue-13482.stderr
index 3eb05f504c2..6226c580811 100644
--- a/tests/ui/issues/issue-13482.stderr
+++ b/tests/ui/issues/issue-13482.stderr
@@ -4,6 +4,6 @@ error[E0527]: pattern requires 0 elements but array has 2
 LL |     [] => None,
    |     ^^ expected 2 elements
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0527`.
diff --git a/tests/ui/issues/issue-13497-2.stderr b/tests/ui/issues/issue-13497-2.stderr
index 8ad921027e2..e2ba1150d07 100644
--- a/tests/ui/issues/issue-13497-2.stderr
+++ b/tests/ui/issues/issue-13497-2.stderr
@@ -9,6 +9,6 @@ LL |       rawLines
 LL | |         .iter().map(|l| l.trim()).collect()
    | |___________________________________________^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/issues/issue-13497.stderr b/tests/ui/issues/issue-13497.stderr
index 4b1d979da36..236e6b48607 100644
--- a/tests/ui/issues/issue-13497.stderr
+++ b/tests/ui/issues/issue-13497.stderr
@@ -10,6 +10,6 @@ help: consider using the `'static` lifetime
 LL |     &'static str
    |      +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/issues/issue-1362.stderr b/tests/ui/issues/issue-1362.stderr
index babbb6e519b..6f6fdff6678 100644
--- a/tests/ui/issues/issue-1362.stderr
+++ b/tests/ui/issues/issue-1362.stderr
@@ -11,6 +11,6 @@ help: change the type of the numeric literal from `i32` to `u32`
 LL |   let x: u32 = 20u32;
    |                  ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-13847.stderr b/tests/ui/issues/issue-13847.stderr
index ded927693b2..1c1855ce94d 100644
--- a/tests/ui/issues/issue-13847.stderr
+++ b/tests/ui/issues/issue-13847.stderr
@@ -4,6 +4,6 @@ error[E0609]: no field `is_failure` on type `!`
 LL |     return.is_failure
    |            ^^^^^^^^^^ unknown field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/issues/issue-14091-2.stderr b/tests/ui/issues/issue-14091-2.stderr
index f8375d4ef90..ac894767059 100644
--- a/tests/ui/issues/issue-14091-2.stderr
+++ b/tests/ui/issues/issue-14091-2.stderr
@@ -13,6 +13,6 @@ note: the trait `Not` must be implemented
   --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/issues/issue-14091.stderr b/tests/ui/issues/issue-14091.stderr
index 0a9640a9e31..83879583b1f 100644
--- a/tests/ui/issues/issue-14091.stderr
+++ b/tests/ui/issues/issue-14091.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     assert!(1,1);
    |     ^^^^^^^^^^^^ expected `bool`, found integer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-14092.stderr b/tests/ui/issues/issue-14092.stderr
index 3a43627e691..0de7b902fe0 100644
--- a/tests/ui/issues/issue-14092.stderr
+++ b/tests/ui/issues/issue-14092.stderr
@@ -9,6 +9,6 @@ help: add missing generic argument
 LL | fn fn1(0: Box<T>) {}
    |              +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/issues/issue-14285.stderr b/tests/ui/issues/issue-14285.stderr
index 5c07066018e..4f89ae51157 100644
--- a/tests/ui/issues/issue-14285.stderr
+++ b/tests/ui/issues/issue-14285.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>(a: &dyn Foo) -> B<'a> {
 LL |     B(a)
    |     ^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/issues/issue-14366.stderr b/tests/ui/issues/issue-14366.stderr
index df61aabf00a..e7bf555c1b7 100644
--- a/tests/ui/issues/issue-14366.stderr
+++ b/tests/ui/issues/issue-14366.stderr
@@ -11,6 +11,6 @@ help: consider borrowing the value, since `&&'static str` can be coerced into `&
 LL |     let _x = &"test" as &dyn (::std::any::Any);
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-1448-2.stderr b/tests/ui/issues/issue-1448-2.stderr
index 203dd92c9fb..a6f1daefe63 100644
--- a/tests/ui/issues/issue-1448-2.stderr
+++ b/tests/ui/issues/issue-1448-2.stderr
@@ -16,6 +16,6 @@ help: change the type of the numeric literal from `i32` to `u32`
 LL |     println!("{}", foo(10u32));
    |                          ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-14541.stderr b/tests/ui/issues/issue-14541.stderr
index b80c68ce473..370e6477901 100644
--- a/tests/ui/issues/issue-14541.stderr
+++ b/tests/ui/issues/issue-14541.stderr
@@ -6,6 +6,6 @@ LL |     let Vec3 { y: _, z: _ } = v;
    |         |
    |         expected `Vec2`, found `Vec3`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-14721.stderr b/tests/ui/issues/issue-14721.stderr
index f07bc7ad4f1..c71b0363eef 100644
--- a/tests/ui/issues/issue-14721.stderr
+++ b/tests/ui/issues/issue-14721.stderr
@@ -4,6 +4,6 @@ error[E0609]: no field `desc` on type `&str`
 LL |     println!("{}", foo.desc);
    |                        ^^^^ unknown field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/issues/issue-1476.stderr b/tests/ui/issues/issue-1476.stderr
index 670bd546335..e30dbfd205b 100644
--- a/tests/ui/issues/issue-1476.stderr
+++ b/tests/ui/issues/issue-1476.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `x` in this scope
 LL |     println!("{}", x);
    |                    ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/issues/issue-14853.stderr b/tests/ui/issues/issue-14853.stderr
index 2adcf55eca9..25dd1e3374d 100644
--- a/tests/ui/issues/issue-14853.stderr
+++ b/tests/ui/issues/issue-14853.stderr
@@ -7,6 +7,6 @@ LL |     fn yay<T: Debug>(_: Option<Self>, thing: &[T]);
 LL |     fn yay<T: Str>(_:Option<X>, thing: &[T]) {
    |               ^^^ impl has extra requirement `T: Str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/issues/issue-14915.stderr b/tests/ui/issues/issue-14915.stderr
index 6e63269293b..279f5772d21 100644
--- a/tests/ui/issues/issue-14915.stderr
+++ b/tests/ui/issues/issue-14915.stderr
@@ -6,6 +6,6 @@ LL |     println!("{}", x + 1);
    |                    |
    |                    Box<isize>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/issues/issue-15034.stderr b/tests/ui/issues/issue-15034.stderr
index f142e260a23..587a5c85e92 100644
--- a/tests/ui/issues/issue-15034.stderr
+++ b/tests/ui/issues/issue-15034.stderr
@@ -6,6 +6,6 @@ LL |     pub fn new(lexer: &'a mut Lexer) -> Parser<'a> {
 LL |         Parser { lexer: lexer }
    |         ^^^^^^^^^^^^^^^^^^^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/issues/issue-15094.stderr b/tests/ui/issues/issue-15094.stderr
index b7c950892dc..8e0fc8f1770 100644
--- a/tests/ui/issues/issue-15094.stderr
+++ b/tests/ui/issues/issue-15094.stderr
@@ -7,6 +7,6 @@ LL |     fn call_once(self, _args: ()) {
    = note: expected signature `extern "rust-call" fn(Debuger<_>, ())`
               found signature `fn(Debuger<_>, ())`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/issues/issue-15207.stderr b/tests/ui/issues/issue-15207.stderr
index 25ce7cb5cc0..a1047e27ba2 100644
--- a/tests/ui/issues/issue-15207.stderr
+++ b/tests/ui/issues/issue-15207.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `push` found for type `!` in the current scope
 LL |         break.push(1)
    |               ^^^^ method not found in `!`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-15381.stderr b/tests/ui/issues/issue-15381.stderr
index 085958411cc..03a0100f1bd 100644
--- a/tests/ui/issues/issue-15381.stderr
+++ b/tests/ui/issues/issue-15381.stderr
@@ -6,6 +6,6 @@ LL |     for &[x,y,z] in values.chunks(3).filter(|&xs| xs.len() == 3) {
    |
    = note: the matched value is of type `&[u8]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/issues/issue-15756.stderr b/tests/ui/issues/issue-15756.stderr
index d9bdc69ad71..af50fe467d1 100644
--- a/tests/ui/issues/issue-15756.stderr
+++ b/tests/ui/issues/issue-15756.stderr
@@ -8,6 +8,6 @@ LL |     &mut something
    = note: all local variables must have a statically known size
    = help: unsized locals are gated as an unstable feature
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-15783.stderr b/tests/ui/issues/issue-15783.stderr
index 598ec7e6053..7ed2e199130 100644
--- a/tests/ui/issues/issue-15783.stderr
+++ b/tests/ui/issues/issue-15783.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | pub fn foo(params: Option<&[&str]>) -> usize {
    |        ^^^ -----------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-15896.stderr b/tests/ui/issues/issue-15896.stderr
index ec0d74596aa..381f6dc2276 100644
--- a/tests/ui/issues/issue-15896.stderr
+++ b/tests/ui/issues/issue-15896.stderr
@@ -7,6 +7,6 @@ LL |         E::B(
 LL |           Tau{t: x},
    |           ^^^^^^^^^ expected `R`, found `Tau`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-15965.stderr b/tests/ui/issues/issue-15965.stderr
index fe06810b8df..14727e74334 100644
--- a/tests/ui/issues/issue-15965.stderr
+++ b/tests/ui/issues/issue-15965.stderr
@@ -6,6 +6,6 @@ LL | |
 LL | |     ()
    | |______^ cannot infer type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-16149.stderr b/tests/ui/issues/issue-16149.stderr
index bb809840b2a..9ffd0e7e645 100644
--- a/tests/ui/issues/issue-16149.stderr
+++ b/tests/ui/issues/issue-16149.stderr
@@ -7,6 +7,6 @@ LL |     static externalValue: isize;
 LL |         externalValue => true,
    |         ^^^^^^^^^^^^^ cannot be named the same as a static
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0530`.
diff --git a/tests/ui/issues/issue-16250.stderr b/tests/ui/issues/issue-16250.stderr
index 5eb5e0864ad..9d3e8811461 100644
--- a/tests/ui/issues/issue-16250.stderr
+++ b/tests/ui/issues/issue-16250.stderr
@@ -18,5 +18,5 @@ LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(improper_ctypes)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-16338.stderr b/tests/ui/issues/issue-16338.stderr
index 0f08485e515..e24b9bfa3c0 100644
--- a/tests/ui/issues/issue-16338.stderr
+++ b/tests/ui/issues/issue-16338.stderr
@@ -9,6 +9,6 @@ LL |     let Slice { data: data, len: len } = "foo";
    = note: expected type `str`
             found struct `Slice<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-16401.stderr b/tests/ui/issues/issue-16401.stderr
index 02f9f3ea8fd..6af920ca439 100644
--- a/tests/ui/issues/issue-16401.stderr
+++ b/tests/ui/issues/issue-16401.stderr
@@ -9,6 +9,6 @@ LL |         Slice { data: data, len: len } => (),
    = note: expected unit type `()`
                  found struct `Slice<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-16562.stderr b/tests/ui/issues/issue-16562.stderr
index 3fe7507e8a4..efbd7f712a4 100644
--- a/tests/ui/issues/issue-16562.stderr
+++ b/tests/ui/issues/issue-16562.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T, M: MatrixShape> Collection for Col<M, usize> {
    |      ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/issues/issue-16683.stderr b/tests/ui/issues/issue-16683.stderr
index fff681b2e0b..39b22ed1f15 100644
--- a/tests/ui/issues/issue-16683.stderr
+++ b/tests/ui/issues/issue-16683.stderr
@@ -9,5 +9,5 @@ LL |     fn b(&self) {
 LL |         self.a();
    |         ^^^^^^^^ argument requires that `'1` must outlive `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-16725.stderr b/tests/ui/issues/issue-16725.stderr
index 5f6eae73e58..a4a406b3d4b 100644
--- a/tests/ui/issues/issue-16725.stderr
+++ b/tests/ui/issues/issue-16725.stderr
@@ -10,6 +10,6 @@ note: the function `bar` is defined here
 LL |     fn bar();
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/issues/issue-16939.stderr b/tests/ui/issues/issue-16939.stderr
index 6db29bc61b1..229ff9f1817 100644
--- a/tests/ui/issues/issue-16939.stderr
+++ b/tests/ui/issues/issue-16939.stderr
@@ -13,6 +13,6 @@ note: callable defined here
 LL | fn _foo<F: Fn()> (f: F) {
    |            ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0057`.
diff --git a/tests/ui/issues/issue-16966.stderr b/tests/ui/issues/issue-16966.stderr
index c53707c5d69..0ed12d3a2e9 100644
--- a/tests/ui/issues/issue-16966.stderr
+++ b/tests/ui/issues/issue-16966.stderr
@@ -11,6 +11,6 @@ LL |     panic!(std::default::Default::default());
 note: required by a bound in `begin_panic`
   --> $SRC_DIR/std/src/panicking.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/issues/issue-17001.stderr b/tests/ui/issues/issue-17001.stderr
index d7e6069977b..6ea32e0a45c 100644
--- a/tests/ui/issues/issue-17001.stderr
+++ b/tests/ui/issues/issue-17001.stderr
@@ -4,6 +4,6 @@ error[E0574]: expected struct, variant or union type, found module `foo`
 LL |     let p = foo { x: () };
    |             ^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/issues/issue-17033.stderr b/tests/ui/issues/issue-17033.stderr
index 3419c079859..0b42274223a 100644
--- a/tests/ui/issues/issue-17033.stderr
+++ b/tests/ui/issues/issue-17033.stderr
@@ -11,6 +11,6 @@ help: consider mutably borrowing here
 LL |     (*p)(&mut ())
    |          ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-17252.stderr b/tests/ui/issues/issue-17252.stderr
index 32e20d77465..d8984860457 100644
--- a/tests/ui/issues/issue-17252.stderr
+++ b/tests/ui/issues/issue-17252.stderr
@@ -17,6 +17,6 @@ LL |     let _x: [u8; FOO]; // caused stack overflow prior to fix
    |                  ^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-17337.stderr b/tests/ui/issues/issue-17337.stderr
index 55e51e566d9..8fbf6882699 100644
--- a/tests/ui/issues/issue-17337.stderr
+++ b/tests/ui/issues/issue-17337.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(deprecated)]
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-17373.stderr b/tests/ui/issues/issue-17373.stderr
index 5c429d1113d..9438f5c6345 100644
--- a/tests/ui/issues/issue-17373.stderr
+++ b/tests/ui/issues/issue-17373.stderr
@@ -4,6 +4,6 @@ error[E0614]: type `!` cannot be dereferenced
 LL |     *return
    |     ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0614`.
diff --git a/tests/ui/issues/issue-17405.stderr b/tests/ui/issues/issue-17405.stderr
index 37274e239ba..47f5bf4dc33 100644
--- a/tests/ui/issues/issue-17405.stderr
+++ b/tests/ui/issues/issue-17405.stderr
@@ -4,6 +4,6 @@ error[E0574]: expected struct, variant or union type, found enum `Foo`
 LL |         Foo { i } => ()
    |         ^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/issues/issue-17551.stderr b/tests/ui/issues/issue-17551.stderr
index 3a8f569a3a5..68f54a31084 100644
--- a/tests/ui/issues/issue-17551.stderr
+++ b/tests/ui/issues/issue-17551.stderr
@@ -9,6 +9,6 @@ help: consider giving `foo` an explicit type, where the type for type parameter
 LL |     let foo: B<T> = B(marker::PhantomData);
    |            ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-17651.stderr b/tests/ui/issues/issue-17651.stderr
index b37811e1955..0c95a3c0c40 100644
--- a/tests/ui/issues/issue-17651.stderr
+++ b/tests/ui/issues/issue-17651.stderr
@@ -10,6 +10,6 @@ LL |     (|| Box::new(*(&[0][..])))();
 note: required by a bound in `Box::<T>::new`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-17758.stderr b/tests/ui/issues/issue-17758.stderr
index 613ef6b907c..7a7d2374ef8 100644
--- a/tests/ui/issues/issue-17758.stderr
+++ b/tests/ui/issues/issue-17758.stderr
@@ -9,5 +9,5 @@ LL |     fn bar(&self) {
 LL |         self.foo();
    |         ^^^^^^^^^^ argument requires that `'1` must outlive `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-17800.stderr b/tests/ui/issues/issue-17800.stderr
index baab675834f..2a15af50d02 100644
--- a/tests/ui/issues/issue-17800.stderr
+++ b/tests/ui/issues/issue-17800.stderr
@@ -9,6 +9,6 @@ help: use the tuple variant pattern syntax instead
 LL |         MyOption::MySome(42) => (),
    |                         ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0769`.
diff --git a/tests/ui/issues/issue-17904-2.stderr b/tests/ui/issues/issue-17904-2.stderr
index 62b7b79538c..102c8537f8e 100644
--- a/tests/ui/issues/issue-17904-2.stderr
+++ b/tests/ui/issues/issue-17904-2.stderr
@@ -6,6 +6,6 @@ LL | struct Foo<T> where T: Copy;
    |
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0392`.
diff --git a/tests/ui/issues/issue-17933.stderr b/tests/ui/issues/issue-17933.stderr
index 33534d3f8f6..42a7e044207 100644
--- a/tests/ui/issues/issue-17933.stderr
+++ b/tests/ui/issues/issue-17933.stderr
@@ -4,6 +4,6 @@ error[E0532]: expected unit struct, unit variant or constant, found static `self
 LL |         self::X => { },
    |         ^^^^^^^ not a unit struct, unit variant or constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/issues/issue-17954.stderr b/tests/ui/issues/issue-17954.stderr
index 3e3706bcb7d..bba7e725b12 100644
--- a/tests/ui/issues/issue-17954.stderr
+++ b/tests/ui/issues/issue-17954.stderr
@@ -7,6 +7,6 @@ LL |     let a = &FOO;
 LL | }
    |  - end of enclosing function is here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0712`.
diff --git a/tests/ui/issues/issue-17959.stderr b/tests/ui/issues/issue-17959.stderr
index fb795febf79..604413c4b6d 100644
--- a/tests/ui/issues/issue-17959.stderr
+++ b/tests/ui/issues/issue-17959.stderr
@@ -10,6 +10,6 @@ note: the implementor must specify the same requirement
 LL | struct G<T: ?Sized> {
    | ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/issues/issue-17994.stderr b/tests/ui/issues/issue-17994.stderr
index 61e1e496f79..ba3def64dfb 100644
--- a/tests/ui/issues/issue-17994.stderr
+++ b/tests/ui/issues/issue-17994.stderr
@@ -4,6 +4,6 @@ error[E0091]: type parameter `T` is unused
 LL | type Huh<T> where T: Tr = isize;
    |          ^ unused type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0091`.
diff --git a/tests/ui/issues/issue-18058.stderr b/tests/ui/issues/issue-18058.stderr
index 18159ffc238..c880bb00291 100644
--- a/tests/ui/issues/issue-18058.stderr
+++ b/tests/ui/issues/issue-18058.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Undefined` in this scope
 LL | impl Undefined {}
    |      ^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/issues/issue-18107.stderr b/tests/ui/issues/issue-18107.stderr
index cf4e06316a7..702207c30f7 100644
--- a/tests/ui/issues/issue-18107.stderr
+++ b/tests/ui/issues/issue-18107.stderr
@@ -17,6 +17,6 @@ LL |     match 0 {
 LL ~         _ => Box::new(unimplemented!())
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0746`.
diff --git a/tests/ui/issues/issue-18159.stderr b/tests/ui/issues/issue-18159.stderr
index 5e0589eed43..5de13a5c314 100644
--- a/tests/ui/issues/issue-18159.stderr
+++ b/tests/ui/issues/issue-18159.stderr
@@ -9,6 +9,6 @@ help: consider giving `x` an explicit type
 LL |     let x: /* Type */;
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-18183.stderr b/tests/ui/issues/issue-18183.stderr
index a7dc64708d8..11015d75d97 100644
--- a/tests/ui/issues/issue-18183.stderr
+++ b/tests/ui/issues/issue-18183.stderr
@@ -4,6 +4,6 @@ error[E0128]: generic parameters with a default cannot use forward declared iden
 LL | pub struct Foo<Bar=Bar>(Bar);
    |                    ^^^ defaulted generic parameters cannot be forward declared
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0128`.
diff --git a/tests/ui/issues/issue-18423.stderr b/tests/ui/issues/issue-18423.stderr
index 5d154dbbbdd..2c6015eaa9d 100644
--- a/tests/ui/issues/issue-18423.stderr
+++ b/tests/ui/issues/issue-18423.stderr
@@ -6,6 +6,6 @@ LL |     x: Box<'a, isize>
    |        |
    |        expected 0 lifetime arguments
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/issues/issue-18446.stderr b/tests/ui/issues/issue-18446.stderr
index 602b80c6824..d84c490df4d 100644
--- a/tests/ui/issues/issue-18446.stderr
+++ b/tests/ui/issues/issue-18446.stderr
@@ -19,6 +19,6 @@ help: disambiguate the method for candidate #2
 LL |     T::foo(&x);
    |     ~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/issues/issue-18532.stderr b/tests/ui/issues/issue-18532.stderr
index 4c224eb2d24..059c7f13781 100644
--- a/tests/ui/issues/issue-18532.stderr
+++ b/tests/ui/issues/issue-18532.stderr
@@ -6,6 +6,6 @@ LL |     (return)((),());
    |     |
    |     call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-18566.stderr b/tests/ui/issues/issue-18566.stderr
index 8db78935f83..e8ec48b0d26 100644
--- a/tests/ui/issues/issue-18566.stderr
+++ b/tests/ui/issues/issue-18566.stderr
@@ -7,6 +7,6 @@ LL |     MyPtr(s).poke(s);
    |           |  first borrow later used by call
    |           first mutable borrow occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/issues/issue-18611.stderr b/tests/ui/issues/issue-18611.stderr
index 784b9b984e9..ab2374586e4 100644
--- a/tests/ui/issues/issue-18611.stderr
+++ b/tests/ui/issues/issue-18611.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait HasState {
    | ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-18819.stderr b/tests/ui/issues/issue-18819.stderr
index 40098f9622f..b2cf0bad1df 100644
--- a/tests/ui/issues/issue-18819.stderr
+++ b/tests/ui/issues/issue-18819.stderr
@@ -25,6 +25,6 @@ help: provide the argument
 LL |     print_x(/* &dyn Foo<Item = bool> */, /* &str */);
    |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/issues/issue-18919.stderr b/tests/ui/issues/issue-18919.stderr
index b0b03a0eea6..6dcd891ceda 100644
--- a/tests/ui/issues/issue-18919.stderr
+++ b/tests/ui/issues/issue-18919.stderr
@@ -18,6 +18,6 @@ LL | enum Option<T> {
 LL |     Some(T),
    |          - ...if indirection were used here: `Box<T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-18959.stderr b/tests/ui/issues/issue-18959.stderr
index b9e27873636..76082dadd37 100644
--- a/tests/ui/issues/issue-18959.stderr
+++ b/tests/ui/issues/issue-18959.stderr
@@ -13,6 +13,6 @@ LL | pub trait Bar: Foo { }
    |           --- this trait cannot be made into an object...
    = help: consider moving `foo` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/issues/issue-1900.stderr b/tests/ui/issues/issue-1900.stderr
index ce413662f0d..31fd46c8e2a 100644
--- a/tests/ui/issues/issue-1900.stderr
+++ b/tests/ui/issues/issue-1900.stderr
@@ -4,6 +4,6 @@ error[E0131]: `main` function is not allowed to have generic parameters
 LL | fn main<T>() { }
    |        ^^^ `main` cannot have generic parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0131`.
diff --git a/tests/ui/issues/issue-19086.stderr b/tests/ui/issues/issue-19086.stderr
index 90d0bb40655..03b9249bb1e 100644
--- a/tests/ui/issues/issue-19086.stderr
+++ b/tests/ui/issues/issue-19086.stderr
@@ -7,6 +7,6 @@ LL |     FooB { x: i32, y: i32 }
 LL |         FooB(a, b) => println!("{} {}", a, b),
    |         ^^^^^^^^^^ help: use struct pattern syntax instead: `FooB { x: a, y: b }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/issues/issue-1920-1.stderr b/tests/ui/issues/issue-1920-1.stderr
index a546924253c..b7c7da00672 100644
--- a/tests/ui/issues/issue-1920-1.stderr
+++ b/tests/ui/issues/issue-1920-1.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `assert_clone`
 LL | fn assert_clone<T>() where T : Clone { }
    |                                ^^^^^ required by this bound in `assert_clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-1920-2.stderr b/tests/ui/issues/issue-1920-2.stderr
index 1083b011252..844cb0ff199 100644
--- a/tests/ui/issues/issue-1920-2.stderr
+++ b/tests/ui/issues/issue-1920-2.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `assert_clone`
 LL | fn assert_clone<T>() where T : Clone { }
    |                                ^^^^^ required by this bound in `assert_clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-1920-3.stderr b/tests/ui/issues/issue-1920-3.stderr
index 3f0787c8875..525ca4685bb 100644
--- a/tests/ui/issues/issue-1920-3.stderr
+++ b/tests/ui/issues/issue-1920-3.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `assert_clone`
 LL | fn assert_clone<T>() where T : Clone { }
    |                                ^^^^^ required by this bound in `assert_clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-19244-1.stderr b/tests/ui/issues/issue-19244-1.stderr
index 3358cac82e0..9c1336402e6 100644
--- a/tests/ui/issues/issue-19244-1.stderr
+++ b/tests/ui/issues/issue-19244-1.stderr
@@ -4,6 +4,6 @@ error[E0609]: no field `1` on type `(usize,)`
 LL |     let a: [isize; TUP.1];
    |                        ^ unknown field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/issues/issue-19244-2.stderr b/tests/ui/issues/issue-19244-2.stderr
index 71655457f90..533861b1114 100644
--- a/tests/ui/issues/issue-19244-2.stderr
+++ b/tests/ui/issues/issue-19244-2.stderr
@@ -6,6 +6,6 @@ LL |     let a: [isize; STRUCT.nonexistent_field];
    |
    = note: available field is: `field`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/issues/issue-19482.stderr b/tests/ui/issues/issue-19482.stderr
index 90e6f799560..903a9f98c75 100644
--- a/tests/ui/issues/issue-19482.stderr
+++ b/tests/ui/issues/issue-19482.stderr
@@ -7,6 +7,6 @@ LL |     type A;
 LL | fn bar(x: &dyn Foo) {}
    |                ^^^ help: specify the associated type: `Foo<A = Type>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0191`.
diff --git a/tests/ui/issues/issue-19521.stderr b/tests/ui/issues/issue-19521.stderr
index 13a12acb360..f451dc36d45 100644
--- a/tests/ui/issues/issue-19521.stderr
+++ b/tests/ui/issues/issue-19521.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `homura` found for reference `&'static str` in the
 LL |     "".homura()();
    |        ^^^^^^ method not found in `&str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-1962.stderr b/tests/ui/issues/issue-1962.stderr
index 4c32a4cf3dd..db235d47303 100644
--- a/tests/ui/issues/issue-1962.stderr
+++ b/tests/ui/issues/issue-1962.stderr
@@ -6,5 +6,5 @@ LL |     'a: while true {
    |
    = note: requested on the command line with `-D while-true`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-19692.stderr b/tests/ui/issues/issue-19692.stderr
index 9e888ed758a..1e3d7a2e2f5 100644
--- a/tests/ui/issues/issue-19692.stderr
+++ b/tests/ui/issues/issue-19692.stderr
@@ -7,6 +7,6 @@ LL | struct Homura;
 LL |     let Some(ref madoka) = Some(homura.kaname());
    |                                        ^^^^^^ method not found in `Homura`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-19734.stderr b/tests/ui/issues/issue-19734.stderr
index 81757974de9..ed48714fe50 100644
--- a/tests/ui/issues/issue-19734.stderr
+++ b/tests/ui/issues/issue-19734.stderr
@@ -4,5 +4,5 @@ error: cannot find macro `undef` in this scope
 LL |     undef!();
    |     ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-19922.stderr b/tests/ui/issues/issue-19922.stderr
index 826b2ac049b..0355d3a8971 100644
--- a/tests/ui/issues/issue-19922.stderr
+++ b/tests/ui/issues/issue-19922.stderr
@@ -6,6 +6,6 @@ LL |     let homura = Homura::Akemi { kaname: () };
    |
    = note: available fields are: `madoka`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0559`.
diff --git a/tests/ui/issues/issue-19991.stderr b/tests/ui/issues/issue-19991.stderr
index 57b0882b636..ff039f3adba 100644
--- a/tests/ui/issues/issue-19991.stderr
+++ b/tests/ui/issues/issue-19991.stderr
@@ -11,6 +11,6 @@ LL | |     };
    = note: `if` expressions without `else` evaluate to `()`
    = help: consider adding an `else` block that evaluates to the expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0317`.
diff --git a/tests/ui/issues/issue-20162.stderr b/tests/ui/issues/issue-20162.stderr
index ebdf2528fe1..8f45f0d36c7 100644
--- a/tests/ui/issues/issue-20162.stderr
+++ b/tests/ui/issues/issue-20162.stderr
@@ -12,6 +12,6 @@ LL + #[derive(Ord)]
 LL | struct X { x: i32 }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-20261.stderr b/tests/ui/issues/issue-20261.stderr
index 9ac751e4dc4..6738708ca22 100644
--- a/tests/ui/issues/issue-20261.stderr
+++ b/tests/ui/issues/issue-20261.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |         i.clone();
    |           ^^^^^ cannot infer type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-20313.stderr b/tests/ui/issues/issue-20313.stderr
index 7a0b344a5aa..f740b0cca06 100644
--- a/tests/ui/issues/issue-20313.stderr
+++ b/tests/ui/issues/issue-20313.stderr
@@ -7,6 +7,6 @@ LL |     fn sqrt(x: f32) -> f32;
    = note: see issue #29602 <https://github.com/rust-lang/rust/issues/29602> for more information
    = help: add `#![feature(link_llvm_intrinsics)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/issues/issue-20433.stderr b/tests/ui/issues/issue-20433.stderr
index 3ae952546a6..2dd0b3c2f84 100644
--- a/tests/ui/issues/issue-20433.stderr
+++ b/tests/ui/issues/issue-20433.stderr
@@ -8,6 +8,6 @@ LL |     fn iceman(c: Vec<[i32]>) {}
 note: required by a bound in `Vec`
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-20714.stderr b/tests/ui/issues/issue-20714.stderr
index a3447aa6845..f537a01582b 100644
--- a/tests/ui/issues/issue-20714.stderr
+++ b/tests/ui/issues/issue-20714.stderr
@@ -15,6 +15,6 @@ LL -     let g = G();
 LL +     let g = G;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-20772.stderr b/tests/ui/issues/issue-20772.stderr
index 0c7e728c67e..81f80aef594 100644
--- a/tests/ui/issues/issue-20772.stderr
+++ b/tests/ui/issues/issue-20772.stderr
@@ -12,6 +12,6 @@ LL | trait T : Iterator<Item=Self::Item>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-20831-debruijn.stderr b/tests/ui/issues/issue-20831-debruijn.stderr
index c3af1f6786b..bd3ff5d59c6 100644
--- a/tests/ui/issues/issue-20831-debruijn.stderr
+++ b/tests/ui/issues/issue-20831-debruijn.stderr
@@ -22,6 +22,6 @@ LL |     fn subscribe(&mut self, t : Box<dyn Subscriber<Input=<Self as Publisher
    = note: expected `<MyStruct<'a> as Publisher<'_>>`
               found `<MyStruct<'_> as Publisher<'_>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0495`.
diff --git a/tests/ui/issues/issue-20939.stderr b/tests/ui/issues/issue-20939.stderr
index 3819a21a2cf..00357155c8a 100644
--- a/tests/ui/issues/issue-20939.stderr
+++ b/tests/ui/issues/issue-20939.stderr
@@ -4,6 +4,6 @@ error[E0371]: the object type `(dyn Foo + 'a)` automatically implements the trai
 LL | impl<'a> Foo for dyn Foo + 'a {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `(dyn Foo + 'a)` automatically implements trait `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0371`.
diff --git a/tests/ui/issues/issue-21160.stderr b/tests/ui/issues/issue-21160.stderr
index b39a3aad371..892a4530ebc 100644
--- a/tests/ui/issues/issue-21160.stderr
+++ b/tests/ui/issues/issue-21160.stderr
@@ -13,6 +13,6 @@ LL + #[derive(Hash)]
 LL | struct Bar;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-21174.stderr b/tests/ui/issues/issue-21174.stderr
index 5981d9dc733..a6b75c91352 100644
--- a/tests/ui/issues/issue-21174.stderr
+++ b/tests/ui/issues/issue-21174.stderr
@@ -7,6 +7,6 @@ LL |     let new: T::B = unsafe { std::mem::transmute(value) };
    = note: source type: `<T as Trait<'_>>::A` (this type does not have a fixed size)
    = note: target type: `<T as Trait<'_>>::B` (this type does not have a fixed size)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/issues/issue-21177.stderr b/tests/ui/issues/issue-21177.stderr
index 8b749edcc77..9f66f43a195 100644
--- a/tests/ui/issues/issue-21177.stderr
+++ b/tests/ui/issues/issue-21177.stderr
@@ -12,6 +12,6 @@ LL | fn foo<T: Trait<A = T::B>>() { }
    |                     ^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-21202.stderr b/tests/ui/issues/issue-21202.stderr
index e7c3f2f9a07..3485994e8f4 100644
--- a/tests/ui/issues/issue-21202.stderr
+++ b/tests/ui/issues/issue-21202.stderr
@@ -9,6 +9,6 @@ LL |         Foo::foo(&f);
 LL |         fn foo(&self) { }
    |         ------------- private method defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/issues/issue-21332.stderr b/tests/ui/issues/issue-21332.stderr
index 82549288064..96e0f5fdb31 100644
--- a/tests/ui/issues/issue-21332.stderr
+++ b/tests/ui/issues/issue-21332.stderr
@@ -10,6 +10,6 @@ LL |     fn next(&mut self) -> Result<i32, i32> { Ok(7) }
    = note: expected signature `fn(&mut S) -> Option<i32>`
               found signature `fn(&mut S) -> Result<i32, i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/issues/issue-21449.stderr b/tests/ui/issues/issue-21449.stderr
index ecaf6faba42..cd1059d4899 100644
--- a/tests/ui/issues/issue-21449.stderr
+++ b/tests/ui/issues/issue-21449.stderr
@@ -4,6 +4,6 @@ error[E0574]: expected struct, variant or union type, found module `MyMod`
 LL |     let myVar = MyMod { T: 0 };
    |                 ^^^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/issues/issue-2150.stderr b/tests/ui/issues/issue-2150.stderr
index 26874faa2b9..a9268646edf 100644
--- a/tests/ui/issues/issue-2150.stderr
+++ b/tests/ui/issues/issue-2150.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-2151.stderr b/tests/ui/issues/issue-2151.stderr
index c75038b6169..b130f162414 100644
--- a/tests/ui/issues/issue-2151.stderr
+++ b/tests/ui/issues/issue-2151.stderr
@@ -11,6 +11,6 @@ help: consider giving `x` an explicit type
 LL |     let x: /* Type */ = panic!();
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-21554.stderr b/tests/ui/issues/issue-21554.stderr
index 6ea552a26a5..b1b59af6ec2 100644
--- a/tests/ui/issues/issue-21554.stderr
+++ b/tests/ui/issues/issue-21554.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `fn(i32) -> Inches {Inches}` as `f32` is invalid
 LL |     Inches as f32;
    |     ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/issues/issue-21596.stderr b/tests/ui/issues/issue-21596.stderr
index a336d1b0ed5..8a7fca5f436 100644
--- a/tests/ui/issues/issue-21596.stderr
+++ b/tests/ui/issues/issue-21596.stderr
@@ -10,6 +10,6 @@ LL |     println!("{}", z.to_string());
            `*const u8: std::fmt::Display`
            which is required by `*const u8: ToString`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-21763.stderr b/tests/ui/issues/issue-21763.stderr
index a887635d354..3d623985cbb 100644
--- a/tests/ui/issues/issue-21763.stderr
+++ b/tests/ui/issues/issue-21763.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `foo`
 LL | fn foo<T: Send>() {}
    |           ^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-21837.stderr b/tests/ui/issues/issue-21837.stderr
index 3d385266499..f1989392688 100644
--- a/tests/ui/issues/issue-21837.stderr
+++ b/tests/ui/issues/issue-21837.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: Bound> Trait2 for Foo<T> {}
    |       +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-21946.stderr b/tests/ui/issues/issue-21946.stderr
index 67f6b3081bb..d1b4a808d2e 100644
--- a/tests/ui/issues/issue-21946.stderr
+++ b/tests/ui/issues/issue-21946.stderr
@@ -4,6 +4,6 @@ error[E0275]: overflow evaluating the requirement `<FooStruct as Foo>::A == _`
 LL |     type A = <FooStruct as Foo>::A;
    |              ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/issues/issue-21974.stderr b/tests/ui/issues/issue-21974.stderr
index 2d60b18b1f2..3934846ea02 100644
--- a/tests/ui/issues/issue-21974.stderr
+++ b/tests/ui/issues/issue-21974.stderr
@@ -12,6 +12,6 @@ LL |     where &'a T : Foo,
 LL |           &'b T : Foo
    |                   ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/issues/issue-22034.stderr b/tests/ui/issues/issue-22034.stderr
index d64b024098c..6d899618d7a 100644
--- a/tests/ui/issues/issue-22034.stderr
+++ b/tests/ui/issues/issue-22034.stderr
@@ -8,6 +8,6 @@ LL |         &mut *(ptr as *mut dyn Fn())
    = note: wrap the `()` in a closure with no arguments: `|| { /* code */ }`
    = note: required for the cast from `*mut ()` to `*mut dyn Fn()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-22289.stderr b/tests/ui/issues/issue-22289.stderr
index b594e8b7a1e..560fbc73bbd 100644
--- a/tests/ui/issues/issue-22289.stderr
+++ b/tests/ui/issues/issue-22289.stderr
@@ -9,6 +9,6 @@ help: consider borrowing the value
 LL |     &0 as &dyn std::any::Any;
    |     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/issues/issue-22312.stderr b/tests/ui/issues/issue-22312.stderr
index da15c092fc3..be3f5ace548 100644
--- a/tests/ui/issues/issue-22312.stderr
+++ b/tests/ui/issues/issue-22312.stderr
@@ -9,6 +9,6 @@ help: consider borrowing the value
 LL |         let indexer = &(&*self as &dyn Index<usize, Output = <Self as Index<usize>>::Output>);
    |                         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/issues/issue-22370.stderr b/tests/ui/issues/issue-22370.stderr
index cd27c4e4e4e..977cfe06bb8 100644
--- a/tests/ui/issues/issue-22370.stderr
+++ b/tests/ui/issues/issue-22370.stderr
@@ -9,6 +9,6 @@ LL | fn f(a: &dyn A) {}
    |
    = note: because of the default `Self` reference, type parameters must be specified on object types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0393`.
diff --git a/tests/ui/issues/issue-22434.stderr b/tests/ui/issues/issue-22434.stderr
index dab62bcbb4d..172ae386c3e 100644
--- a/tests/ui/issues/issue-22434.stderr
+++ b/tests/ui/issues/issue-22434.stderr
@@ -7,6 +7,6 @@ LL |     type A;
 LL | type I<'a> = &'a (dyn Foo + 'a);
    |                       ^^^ help: specify the associated type: `Foo<A = Type>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0191`.
diff --git a/tests/ui/issues/issue-22468.stderr b/tests/ui/issues/issue-22468.stderr
index fb2b9b42859..052888d2029 100644
--- a/tests/ui/issues/issue-22468.stderr
+++ b/tests/ui/issues/issue-22468.stderr
@@ -11,6 +11,6 @@ LL |     let x = foo("baz");
 LL | fn foo(file: &str) -> bool {
    | -------------------------- this function of the same name is available here, but it's shadowed by the local binding
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-22599.stderr b/tests/ui/issues/issue-22599.stderr
index 2b34830d084..b599f6febe3 100644
--- a/tests/ui/issues/issue-22599.stderr
+++ b/tests/ui/issues/issue-22599.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-22638.stderr b/tests/ui/issues/issue-22638.stderr
index 1caa4221f25..a372078abd8 100644
--- a/tests/ui/issues/issue-22638.stderr
+++ b/tests/ui/issues/issue-22638.stderr
@@ -10,5 +10,5 @@ note: `A::matches` defined here
 LL |     pub fn matches<F: Fn()>(&self, f: &F) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-22684.stderr b/tests/ui/issues/issue-22684.stderr
index 2407ece5e4f..e2ca54caeac 100644
--- a/tests/ui/issues/issue-22684.stderr
+++ b/tests/ui/issues/issue-22684.stderr
@@ -6,6 +6,6 @@ LL |     let _: () = foo::Foo.bar();
    |            |
    |            expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-22706.stderr b/tests/ui/issues/issue-22706.stderr
index 5366a36b1a6..309e11a25f1 100644
--- a/tests/ui/issues/issue-22706.stderr
+++ b/tests/ui/issues/issue-22706.stderr
@@ -6,6 +6,6 @@ LL | fn is_copy<T: ::std::marker<i32>::Copy>() {}
    |                      |
    |                      not allowed on module `marker`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/issues/issue-2281-part1.stderr b/tests/ui/issues/issue-2281-part1.stderr
index c2391a7c091..47a1ef8cc02 100644
--- a/tests/ui/issues/issue-2281-part1.stderr
+++ b/tests/ui/issues/issue-2281-part1.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `foobar` in this scope
 LL | fn main() { println!("{}", foobar); }
    |                            ^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/issues/issue-22872.stderr b/tests/ui/issues/issue-22872.stderr
index 63222d25c01..6ff710b1133 100644
--- a/tests/ui/issues/issue-22872.stderr
+++ b/tests/ui/issues/issue-22872.stderr
@@ -19,6 +19,6 @@ help: consider further restricting the associated type
 LL | fn push_process<P>(process: P) where P: Process<'static>, <P as Process<'_>>::Item: Iterator {
    |                                                         ++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-22874.stderr b/tests/ui/issues/issue-22874.stderr
index d6489908044..717ce72b9c1 100644
--- a/tests/ui/issues/issue-22874.stderr
+++ b/tests/ui/issues/issue-22874.stderr
@@ -7,6 +7,6 @@ LL |     rows: [[String]],
    = help: the trait `Sized` is not implemented for `[String]`
    = note: slice and array elements must have `Sized` type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-22886.stderr b/tests/ui/issues/issue-22886.stderr
index c4b39655924..a04fa677f9e 100644
--- a/tests/ui/issues/issue-22886.stderr
+++ b/tests/ui/issues/issue-22886.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a> Iterator for Newtype {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/issues/issue-22933-2.stderr b/tests/ui/issues/issue-22933-2.stderr
index 1a0e87e15d6..8cda8598f3c 100644
--- a/tests/ui/issues/issue-22933-2.stderr
+++ b/tests/ui/issues/issue-22933-2.stderr
@@ -10,6 +10,6 @@ LL |     ApplePie = Delicious::Apple as isize | Delicious::PIE as isize,
    |                                                       variant or associated item not found in `Delicious`
    |                                                       help: there is a variant with a similar name: `Pie`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-23041.stderr b/tests/ui/issues/issue-23041.stderr
index 4271c67c3bc..0142926dd15 100644
--- a/tests/ui/issues/issue-23041.stderr
+++ b/tests/ui/issues/issue-23041.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     b.downcast_ref::<fn(_) -> _>();
    |                   ~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-23046.stderr b/tests/ui/issues/issue-23046.stderr
index 1403ecbd92d..b6e23814543 100644
--- a/tests/ui/issues/issue-23046.stderr
+++ b/tests/ui/issues/issue-23046.stderr
@@ -9,6 +9,6 @@ help: consider giving this closure parameter an explicit type, where the type fo
 LL |     let ex = |x: Expr<'_, VAR>| {
    |                +++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-23073.stderr b/tests/ui/issues/issue-23073.stderr
index 3a9f49ef167..6a61df8d46b 100644
--- a/tests/ui/issues/issue-23073.stderr
+++ b/tests/ui/issues/issue-23073.stderr
@@ -9,6 +9,6 @@ help: if there were a trait named `Example` with associated type `T` implemented
 LL |     type FooT = <<Self as Bar>::Foo as Example>::T;
    |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/issues/issue-23122-1.stderr b/tests/ui/issues/issue-23122-1.stderr
index 0b568b30e08..c432a502c13 100644
--- a/tests/ui/issues/issue-23122-1.stderr
+++ b/tests/ui/issues/issue-23122-1.stderr
@@ -4,6 +4,6 @@ error[E0275]: overflow evaluating the requirement `<GetNext<T> as Next>::Next ==
 LL |     type Next = <GetNext<T> as Next>::Next;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/issues/issue-23122-2.stderr b/tests/ui/issues/issue-23122-2.stderr
index af77e4b1a41..b8aa587a739 100644
--- a/tests/ui/issues/issue-23122-2.stderr
+++ b/tests/ui/issues/issue-23122-2.stderr
@@ -13,6 +13,6 @@ LL | impl<T: Next> Next for GetNext<T> {
    |      |
    |      unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/issues/issue-23189.stderr b/tests/ui/issues/issue-23189.stderr
index ed065212c56..37d778dc992 100644
--- a/tests/ui/issues/issue-23189.stderr
+++ b/tests/ui/issues/issue-23189.stderr
@@ -4,6 +4,6 @@ error[E0574]: expected struct, variant or union type, found module `module`
 LL |     let _ = module { x: 0 };
    |             ^^^^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/issues/issue-23217.stderr b/tests/ui/issues/issue-23217.stderr
index 5d3d8a4f808..05ee0474c78 100644
--- a/tests/ui/issues/issue-23217.stderr
+++ b/tests/ui/issues/issue-23217.stderr
@@ -9,6 +9,6 @@ LL |     B = SomeEnum::A,
    |                   variant or associated item not found in `SomeEnum`
    |                   help: there is a variant with a similar name: `B`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-23253.stderr b/tests/ui/issues/issue-23253.stderr
index 44f01c1c167..ec7696909e7 100644
--- a/tests/ui/issues/issue-23253.stderr
+++ b/tests/ui/issues/issue-23253.stderr
@@ -4,6 +4,6 @@ error[E0609]: no field `a` on type `Foo`
 LL |     Foo::Bar.a;
    |              ^ unknown field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/issues/issue-23281.stderr b/tests/ui/issues/issue-23281.stderr
index 804334c9b0d..e1f4e8a96c8 100644
--- a/tests/ui/issues/issue-23281.stderr
+++ b/tests/ui/issues/issue-23281.stderr
@@ -18,6 +18,6 @@ LL | struct Vec<T> {
 LL |     t: T,
    |        - ...if indirection were used here: `Box<T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-23302-1.stderr b/tests/ui/issues/issue-23302-1.stderr
index d753bdeb9f7..5c2758dc609 100644
--- a/tests/ui/issues/issue-23302-1.stderr
+++ b/tests/ui/issues/issue-23302-1.stderr
@@ -17,6 +17,6 @@ LL |     A = X::A as isize,
    |         ^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-23302-2.stderr b/tests/ui/issues/issue-23302-2.stderr
index b756ee1d5e2..93665af69dd 100644
--- a/tests/ui/issues/issue-23302-2.stderr
+++ b/tests/ui/issues/issue-23302-2.stderr
@@ -17,6 +17,6 @@ LL |     A = Y::B as isize,
    |         ^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-23302-3.stderr b/tests/ui/issues/issue-23302-3.stderr
index 6cdc94551fe..b3e933a2171 100644
--- a/tests/ui/issues/issue-23302-3.stderr
+++ b/tests/ui/issues/issue-23302-3.stderr
@@ -27,6 +27,6 @@ LL | const A: i32 = B;
    | ^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-23543.stderr b/tests/ui/issues/issue-23543.stderr
index ebb70afe316..d917a4c51d5 100644
--- a/tests/ui/issues/issue-23543.stderr
+++ b/tests/ui/issues/issue-23543.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |         where T<Bogus = Foo>: A;
    |                 ^^^^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/issues/issue-23544.stderr b/tests/ui/issues/issue-23544.stderr
index c912baccb49..2a7e93f0eb7 100644
--- a/tests/ui/issues/issue-23544.stderr
+++ b/tests/ui/issues/issue-23544.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |         where T<Bogus = Self::AlsoBogus>: A;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/issues/issue-23966.stderr b/tests/ui/issues/issue-23966.stderr
index 542aed0eb26..c29e8861444 100644
--- a/tests/ui/issues/issue-23966.stderr
+++ b/tests/ui/issues/issue-23966.stderr
@@ -10,6 +10,6 @@ LL |     "".chars().fold(|_, _| (), ());
 note: required by a bound in `fold`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-24013.stderr b/tests/ui/issues/issue-24013.stderr
index 72102f460e0..37a86ecc543 100644
--- a/tests/ui/issues/issue-24013.stderr
+++ b/tests/ui/issues/issue-24013.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     unsafe {swap::<&mut _>(transmute(&a), transmute(&b))};
    |             ^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `swap`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-24322.stderr b/tests/ui/issues/issue-24322.stderr
index 954fd492812..b260d027388 100644
--- a/tests/ui/issues/issue-24322.stderr
+++ b/tests/ui/issues/issue-24322.stderr
@@ -9,6 +9,6 @@ LL |     let x: &fn(&B) -> u32 = &B::func;
    = note: expected reference `&for<'a> fn(&'a B) -> u32`
               found reference `&for<'a> fn(&'a B) -> u32 {B::func}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-24352.stderr b/tests/ui/issues/issue-24352.stderr
index f1c3891b870..015569cce06 100644
--- a/tests/ui/issues/issue-24352.stderr
+++ b/tests/ui/issues/issue-24352.stderr
@@ -15,6 +15,6 @@ help: consider using a floating-point literal by writing it with `.0`
 LL |     1.0f64 - 1.0
    |               ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-24357.stderr b/tests/ui/issues/issue-24357.stderr
index b9e15f5e21b..08a5a8ac56e 100644
--- a/tests/ui/issues/issue-24357.stderr
+++ b/tests/ui/issues/issue-24357.stderr
@@ -12,6 +12,6 @@ LL |    let f = move || { let y = x; };
 LL |    let z = x;
    |            ^ value used here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/issues/issue-24424.stderr b/tests/ui/issues/issue-24424.stderr
index 50d7f988e19..d42750e7a2b 100644
--- a/tests/ui/issues/issue-24424.stderr
+++ b/tests/ui/issues/issue-24424.stderr
@@ -10,6 +10,6 @@ note: multiple `impl`s or `where` clauses satisfying `T0: Trait0<'l0>` found
 LL | impl <'l0, 'l1, T0> Trait1<'l0, T0> for bool where T0 : Trait0<'l0>, T0 : Trait0<'l1> {}
    |                                                         ^^^^^^^^^^^       ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/issues/issue-24819.stderr b/tests/ui/issues/issue-24819.stderr
index 8b4f1dbce43..8ec34aa13fa 100644
--- a/tests/ui/issues/issue-24819.stderr
+++ b/tests/ui/issues/issue-24819.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn foo(h: &mut HashSet<u32>) {
    |    ^^^ --------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-25076.stderr b/tests/ui/issues/issue-25076.stderr
index 065bf7def42..2acfe70b485 100644
--- a/tests/ui/issues/issue-25076.stderr
+++ b/tests/ui/issues/issue-25076.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `do_fold`
 LL | fn do_fold<B, F: InOut<B, Out=B>>(init: B, f: F) {}
    |                  ^^^^^^^^^^^^^^^ required by this bound in `do_fold`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-25368.stderr b/tests/ui/issues/issue-25368.stderr
index e6ed3aac710..23f1441e69d 100644
--- a/tests/ui/issues/issue-25368.stderr
+++ b/tests/ui/issues/issue-25368.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |         tx.send(Foo{ foo: PhantomData::<T> });
    |                                      +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-25386.stderr b/tests/ui/issues/issue-25386.stderr
index 727b9690829..720b77866a5 100644
--- a/tests/ui/issues/issue-25386.stderr
+++ b/tests/ui/issues/issue-25386.stderr
@@ -9,6 +9,6 @@ LL |     println!("{}", check_ptr_exist!(item, name));
    |
    = note: this error originates in the macro `check_ptr_exist` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/issues/issue-2590.stderr b/tests/ui/issues/issue-2590.stderr
index 6aacd563af1..517b4814eae 100644
--- a/tests/ui/issues/issue-2590.stderr
+++ b/tests/ui/issues/issue-2590.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of `self.tokens` which is behind a shared referenc
 LL |         self.tokens
    |         ^^^^^^^^^^^ move occurs because `self.tokens` has type `Vec<isize>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/issues/issue-25901.stderr b/tests/ui/issues/issue-25901.stderr
index 1427e43854f..673f29fff18 100644
--- a/tests/ui/issues/issue-25901.stderr
+++ b/tests/ui/issues/issue-25901.stderr
@@ -19,6 +19,6 @@ LL | impl Deref for A {
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
    = note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/issues/issue-26056.stderr b/tests/ui/issues/issue-26056.stderr
index 2c873243fe9..f1f553adf0f 100644
--- a/tests/ui/issues/issue-26056.stderr
+++ b/tests/ui/issues/issue-26056.stderr
@@ -12,6 +12,6 @@ LL | trait Map: MapLookup<<Self as Map>::Key> {
    |       |
    |       this trait cannot be made into an object...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/issues/issue-26217.stderr b/tests/ui/issues/issue-26217.stderr
index 73c772205c3..0b153ad7490 100644
--- a/tests/ui/issues/issue-26217.stderr
+++ b/tests/ui/issues/issue-26217.stderr
@@ -12,5 +12,5 @@ note: due to current limitations in the borrow checker, this implies a `'static`
 LL | fn foo<T>() where for<'a> T: 'a {}
    |                              ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-26237.stderr b/tests/ui/issues/issue-26237.stderr
index 91d28a5e1e1..d15e5753a25 100644
--- a/tests/ui/issues/issue-26237.stderr
+++ b/tests/ui/issues/issue-26237.stderr
@@ -10,6 +10,6 @@ LL |     let mut value_b = 0;
 LL |     macro_panic!(value_a, value_b);
    |                  ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-26619.stderr b/tests/ui/issues/issue-26619.stderr
index 1282fd7d3c2..9175bd2a303 100644
--- a/tests/ui/issues/issue-26619.stderr
+++ b/tests/ui/issues/issue-26619.stderr
@@ -6,6 +6,6 @@ LL |         for s in vec!["1|2".to_string()].into_iter().filter_map(|ref line|
    |                                                                  |
    |                                                                  function parameter borrowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/issues/issue-26812.stderr b/tests/ui/issues/issue-26812.stderr
index fd1bbb9c567..c2a3d4b83d5 100644
--- a/tests/ui/issues/issue-26812.stderr
+++ b/tests/ui/issues/issue-26812.stderr
@@ -4,6 +4,6 @@ error[E0128]: generic parameters with a default cannot use forward declared iden
 LL | fn avg<T=T::Item>(_: T) {}
    |          ^^^^^^^ defaulted generic parameters cannot be forward declared
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0128`.
diff --git a/tests/ui/issues/issue-26905.stderr b/tests/ui/issues/issue-26905.stderr
index 10dbb732585..86f6a14cd10 100644
--- a/tests/ui/issues/issue-26905.stderr
+++ b/tests/ui/issues/issue-26905.stderr
@@ -7,6 +7,6 @@ LL | impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<MyRc<U>> for MyRc<T>{
    = note: `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced
    = note: currently, 2 fields need coercions: `_ptr` (`*const T` to `*const U`), `_boo` (`NotPhantomData<T>` to `NotPhantomData<U>`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0375`.
diff --git a/tests/ui/issues/issue-26948.stderr b/tests/ui/issues/issue-26948.stderr
index faede168767..982c9758a3b 100644
--- a/tests/ui/issues/issue-26948.stderr
+++ b/tests/ui/issues/issue-26948.stderr
@@ -4,6 +4,6 @@ error[E0436]: functional record update syntax requires a struct
 LL |     Foo::A { x: 6, ..orig };
    |                      ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0436`.
diff --git a/tests/ui/issues/issue-27008.stderr b/tests/ui/issues/issue-27008.stderr
index 9d18045aa79..b4bfaa27863 100644
--- a/tests/ui/issues/issue-27008.stderr
+++ b/tests/ui/issues/issue-27008.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     let b = [0; S];
    |                 ^ expected `usize`, found `S`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-27078.stderr b/tests/ui/issues/issue-27078.stderr
index ced92bbd484..d0ba9f6ae2b 100644
--- a/tests/ui/issues/issue-27078.stderr
+++ b/tests/ui/issues/issue-27078.stderr
@@ -14,6 +14,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL |     fn foo(&self) -> &'static i32 {
    |            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-27340.stderr b/tests/ui/issues/issue-27340.stderr
index 9caaffd9c9a..3353b83f4e5 100644
--- a/tests/ui/issues/issue-27340.stderr
+++ b/tests/ui/issues/issue-27340.stderr
@@ -9,6 +9,6 @@ LL | struct Bar(Foo);
    |
    = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/issues/issue-27433.stderr b/tests/ui/issues/issue-27433.stderr
index da751a64957..aba8e612858 100644
--- a/tests/ui/issues/issue-27433.stderr
+++ b/tests/ui/issues/issue-27433.stderr
@@ -6,6 +6,6 @@ LL |     const FOO : u32 = foo;
    |     |
    |     help: consider using `let` instead of `const`: `let FOO`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/issues/issue-2823.stderr b/tests/ui/issues/issue-2823.stderr
index b5a2b2f55a6..5cd3f080450 100644
--- a/tests/ui/issues/issue-2823.stderr
+++ b/tests/ui/issues/issue-2823.stderr
@@ -11,6 +11,6 @@ LL |     let _d = c.clone();
    = note: the following trait defines an item `clone`, perhaps you need to implement it:
            candidate #1: `Clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-2848.stderr b/tests/ui/issues/issue-2848.stderr
index 71ed7d70b5b..873f7efcd73 100644
--- a/tests/ui/issues/issue-2848.stderr
+++ b/tests/ui/issues/issue-2848.stderr
@@ -6,6 +6,6 @@ LL |       alpha | beta => {}
    |       |
    |       pattern doesn't bind `beta`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/issues/issue-2849.stderr b/tests/ui/issues/issue-2849.stderr
index 9027098d2d1..ef5cdb42e61 100644
--- a/tests/ui/issues/issue-2849.stderr
+++ b/tests/ui/issues/issue-2849.stderr
@@ -6,6 +6,6 @@ LL |       Foo::Alpha | Foo::Beta(i) => {}
    |       |
    |       pattern doesn't bind `i`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/issues/issue-28568.stderr b/tests/ui/issues/issue-28568.stderr
index 960259080f7..c8db0403e59 100644
--- a/tests/ui/issues/issue-28568.stderr
+++ b/tests/ui/issues/issue-28568.stderr
@@ -7,6 +7,6 @@ LL | impl Drop for MyStruct {
 LL | impl Drop for MyStruct {
    | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyStruct`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/issues/issue-28586.stderr b/tests/ui/issues/issue-28586.stderr
index d19c4af2df7..33f40a341c8 100644
--- a/tests/ui/issues/issue-28586.stderr
+++ b/tests/ui/issues/issue-28586.stderr
@@ -4,6 +4,6 @@ error[E0599]: no associated item named `BYTES` found for type `usize` in the cur
 LL | impl Foo for [u8; usize::BYTES] {}
    |                          ^^^^^ associated item not found in `usize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-28625.stderr b/tests/ui/issues/issue-28625.stderr
index 7ee0cd48670..3600622a454 100644
--- a/tests/ui/issues/issue-28625.stderr
+++ b/tests/ui/issues/issue-28625.stderr
@@ -7,6 +7,6 @@ LL |     unsafe { std::mem::transmute(a) }
    = note: source type: `&ArrayPeano<T>` (N bits)
    = note: target type: `&[T]` (N bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/issues/issue-28776.mir.stderr b/tests/ui/issues/issue-28776.mir.stderr
index 1d470fb5e0f..e7b7ba08268 100644
--- a/tests/ui/issues/issue-28776.mir.stderr
+++ b/tests/ui/issues/issue-28776.mir.stderr
@@ -6,6 +6,6 @@ LL |     (&ptr::write)(1 as *mut _, 42);
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/issues/issue-28776.thir.stderr b/tests/ui/issues/issue-28776.thir.stderr
index e3562810b3a..63172b85424 100644
--- a/tests/ui/issues/issue-28776.thir.stderr
+++ b/tests/ui/issues/issue-28776.thir.stderr
@@ -6,6 +6,6 @@ LL |     (&ptr::write)(1 as *mut _, 42);
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/issues/issue-28971.stderr b/tests/ui/issues/issue-28971.stderr
index 2eb8a1c2653..8fd3c7ffc30 100644
--- a/tests/ui/issues/issue-28971.stderr
+++ b/tests/ui/issues/issue-28971.stderr
@@ -10,6 +10,6 @@ LL |             Foo::Baz(..) => (),
    |                  variant or associated item not found in `Foo`
    |                  help: there is a variant with a similar name: `Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-29147.stderr b/tests/ui/issues/issue-29147.stderr
index d0d9485310b..a9cda55fd9a 100644
--- a/tests/ui/issues/issue-29147.stderr
+++ b/tests/ui/issues/issue-29147.stderr
@@ -12,6 +12,6 @@ LL | impl Foo for S5<u32> { fn xxx(&self) {} }
 LL | impl Foo for S5<u64> { fn xxx(&self) {} }
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/issues/issue-2951.stderr b/tests/ui/issues/issue-2951.stderr
index 538bbe2f502..134808b4d23 100644
--- a/tests/ui/issues/issue-2951.stderr
+++ b/tests/ui/issues/issue-2951.stderr
@@ -15,6 +15,6 @@ LL |     xx = y;
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-29861.stderr b/tests/ui/issues/issue-29861.stderr
index d9d3cf360df..e7860c19eaa 100644
--- a/tests/ui/issues/issue-29861.stderr
+++ b/tests/ui/issues/issue-29861.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a, T: 'a> MakeRef2 for T {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/issues/issue-2995.stderr b/tests/ui/issues/issue-2995.stderr
index 0d09612c6c2..f4a08e1751f 100644
--- a/tests/ui/issues/issue-2995.stderr
+++ b/tests/ui/issues/issue-2995.stderr
@@ -10,6 +10,6 @@ LL -     let _q: &isize = p as &isize;
 LL +     let _q: &isize = &*p;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/issues/issue-30007.stderr b/tests/ui/issues/issue-30007.stderr
index 87e770e1543..f303221cf8a 100644
--- a/tests/ui/issues/issue-30007.stderr
+++ b/tests/ui/issues/issue-30007.stderr
@@ -9,5 +9,5 @@ LL |     let i: Vec<t!()>;
    |
    = note: the usage of `t!` is likely invalid in type context
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-30123.stderr b/tests/ui/issues/issue-30123.stderr
index a00a1dbb884..cf71a01b58a 100644
--- a/tests/ui/issues/issue-30123.stderr
+++ b/tests/ui/issues/issue-30123.stderr
@@ -7,6 +7,6 @@ LL |     let ug = Graph::<i32, i32>::new_undirected();
    = note: the function or associated item was found for
            - `issue_30123_aux::Graph<N, E, Undirected>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-3021-b.stderr b/tests/ui/issues/issue-3021-b.stderr
index 72289c5f9c3..48777fec0a3 100644
--- a/tests/ui/issues/issue-3021-b.stderr
+++ b/tests/ui/issues/issue-3021-b.stderr
@@ -6,6 +6,6 @@ LL |            self.v0 = k0 ^ 0x736f6d6570736575;
    |
    = help: use the `|| { ... }` closure form instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0434`.
diff --git a/tests/ui/issues/issue-30236.stderr b/tests/ui/issues/issue-30236.stderr
index 64cbd58d695..0f69f49f505 100644
--- a/tests/ui/issues/issue-30236.stderr
+++ b/tests/ui/issues/issue-30236.stderr
@@ -4,6 +4,6 @@ error[E0091]: type parameter `Unused` is unused
 LL |     Unused
    |     ^^^^^^ unused type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0091`.
diff --git a/tests/ui/issues/issue-30589.stderr b/tests/ui/issues/issue-30589.stderr
index 4b88547a1af..6f97a189cea 100644
--- a/tests/ui/issues/issue-30589.stderr
+++ b/tests/ui/issues/issue-30589.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `DecoderError` in this scope
 LL | impl fmt::Display for DecoderError {
    |                       ^^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/issues/issue-31011.stderr b/tests/ui/issues/issue-31011.stderr
index 4971e3357b4..9785d56f4fc 100644
--- a/tests/ui/issues/issue-31011.stderr
+++ b/tests/ui/issues/issue-31011.stderr
@@ -12,6 +12,6 @@ LL |     log!(context, "entered wrapper");
    |
    = note: this error originates in the macro `log` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/issues/issue-31511.stderr b/tests/ui/issues/issue-31511.stderr
index cb2991809dd..177b78754cc 100644
--- a/tests/ui/issues/issue-31511.stderr
+++ b/tests/ui/issues/issue-31511.stderr
@@ -4,6 +4,6 @@ error[E0607]: cannot cast thin pointer `*const ()` to fat pointer `*const [u8]`
 LL |     x as *const [u8];
    |     ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0607`.
diff --git a/tests/ui/issues/issue-3154.stderr b/tests/ui/issues/issue-3154.stderr
index da2af83ff03..3106aaddc4a 100644
--- a/tests/ui/issues/issue-3154.stderr
+++ b/tests/ui/issues/issue-3154.stderr
@@ -6,6 +6,6 @@ LL | fn thing<'a,Q>(x: &Q) -> Thing<'a,Q> {
 LL |     Thing { x: x }
    |     ^^^^^^^^^^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/issues/issue-31910.stderr b/tests/ui/issues/issue-31910.stderr
index 2603c944207..6ef84d7daef 100644
--- a/tests/ui/issues/issue-31910.stderr
+++ b/tests/ui/issues/issue-31910.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     X = Trait::Number,
    |         ^^^^^^^^^^^^^ expected `isize`, found `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-32122-1.stderr b/tests/ui/issues/issue-32122-1.stderr
index b4f5b129667..ae5dffe1fad 100644
--- a/tests/ui/issues/issue-32122-1.stderr
+++ b/tests/ui/issues/issue-32122-1.stderr
@@ -13,6 +13,6 @@ help: consider dereferencing
 LL |     let _: *const u8 = &*a;
    |                         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-32122-2.stderr b/tests/ui/issues/issue-32122-2.stderr
index 02c335c1547..eb4327bef62 100644
--- a/tests/ui/issues/issue-32122-2.stderr
+++ b/tests/ui/issues/issue-32122-2.stderr
@@ -13,6 +13,6 @@ help: consider dereferencing
 LL |     let _: *const u8 = &***a;
    |                         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-32326.stderr b/tests/ui/issues/issue-32326.stderr
index dc51198d98c..1989a915cc1 100644
--- a/tests/ui/issues/issue-32326.stderr
+++ b/tests/ui/issues/issue-32326.stderr
@@ -11,6 +11,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     Plus(Box<Expr>, Expr),
    |          ++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/issues/issue-32377.stderr b/tests/ui/issues/issue-32377.stderr
index 5e870eb3e8d..01a81cea1ec 100644
--- a/tests/ui/issues/issue-32377.stderr
+++ b/tests/ui/issues/issue-32377.stderr
@@ -7,6 +7,6 @@ LL |     unsafe { mem::transmute(x) }
    = note: source type: `[usize; 2]` (N bits)
    = note: target type: `Bar<U>` (N bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/issues/issue-32782.stderr b/tests/ui/issues/issue-32782.stderr
index a6c55ba03fc..477c01f6864 100644
--- a/tests/ui/issues/issue-32782.stderr
+++ b/tests/ui/issues/issue-32782.stderr
@@ -10,6 +10,6 @@ LL | foo!();
    = help: add `#![feature(allow_internal_unstable)]` to the crate attributes to enable
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/issues/issue-33293.stderr b/tests/ui/issues/issue-33293.stderr
index c8450f40042..5badaa153f2 100644
--- a/tests/ui/issues/issue-33293.stderr
+++ b/tests/ui/issues/issue-33293.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `aaa`
 LL |         aaa::bbb(_) => ()
    |         ^^^ use of undeclared crate or module `aaa`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/issues/issue-3344.stderr b/tests/ui/issues/issue-3344.stderr
index e849f5d0490..eac8f10fcc1 100644
--- a/tests/ui/issues/issue-3344.stderr
+++ b/tests/ui/issues/issue-3344.stderr
@@ -6,6 +6,6 @@ LL | impl PartialOrd for Thing {
    |
    = help: implement the missing item: `fn partial_cmp(&self, _: &Thing) -> Option<std::cmp::Ordering> { todo!() }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/issues/issue-33504.stderr b/tests/ui/issues/issue-33504.stderr
index a831cf585f4..f3e1ca08b6f 100644
--- a/tests/ui/issues/issue-33504.stderr
+++ b/tests/ui/issues/issue-33504.stderr
@@ -11,6 +11,6 @@ LL |         let Test = 1;
    |             `Test` is interpreted as a unit struct, not a new binding
    |             help: introduce a new binding instead: `other_test`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-34047.stderr b/tests/ui/issues/issue-34047.stderr
index f770ded50d0..97b1230ce35 100644
--- a/tests/ui/issues/issue-34047.stderr
+++ b/tests/ui/issues/issue-34047.stderr
@@ -7,6 +7,6 @@ LL | const C: u8 = 0;
 LL |         mut C => {}
    |             ^ cannot be named the same as a constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0530`.
diff --git a/tests/ui/issues/issue-34209.stderr b/tests/ui/issues/issue-34209.stderr
index f9a25b69ff6..41bc60d03dd 100644
--- a/tests/ui/issues/issue-34209.stderr
+++ b/tests/ui/issues/issue-34209.stderr
@@ -7,6 +7,6 @@ LL | enum S {
 LL |         S::B {} => {},
    |            ^ help: there is a variant with a similar name: `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-34229.stderr b/tests/ui/issues/issue-34229.stderr
index 69ef876d255..e6aa0d25934 100644
--- a/tests/ui/issues/issue-34229.stderr
+++ b/tests/ui/issues/issue-34229.stderr
@@ -13,6 +13,6 @@ help: consider annotating `Comparable` with `#[derive(PartialOrd)]`
 LL | #[derive(PartialEq)] #[derive(PartialOrd)]
    |                      +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-34349.stderr b/tests/ui/issues/issue-34349.stderr
index 8e9a16619f3..6a6188f10c8 100644
--- a/tests/ui/issues/issue-34349.stderr
+++ b/tests/ui/issues/issue-34349.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `apply`
 LL |     fn apply<F>(f: F) where F: Fn() {
    |                                ^^^^ required by this bound in `apply`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/issues/issue-34373.stderr b/tests/ui/issues/issue-34373.stderr
index 0f0821518a4..c6906734b2d 100644
--- a/tests/ui/issues/issue-34373.stderr
+++ b/tests/ui/issues/issue-34373.stderr
@@ -23,6 +23,6 @@ LL | | }
    | |_^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/issues/issue-3477.stderr b/tests/ui/issues/issue-3477.stderr
index fd5f7dcf6e6..2a4d6d2449e 100644
--- a/tests/ui/issues/issue-3477.stderr
+++ b/tests/ui/issues/issue-3477.stderr
@@ -6,6 +6,6 @@ LL |     let _p: char = 100;
    |             |
    |             expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-35139.stderr b/tests/ui/issues/issue-35139.stderr
index 79e889b7e59..875af704832 100644
--- a/tests/ui/issues/issue-35139.stderr
+++ b/tests/ui/issues/issue-35139.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a> MethodType for MTFn {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/issues/issue-3521-2.stderr b/tests/ui/issues/issue-3521-2.stderr
index 84c7a9efa35..0be0e93c19e 100644
--- a/tests/ui/issues/issue-3521-2.stderr
+++ b/tests/ui/issues/issue-3521-2.stderr
@@ -6,6 +6,6 @@ LL |     static y: isize = foo + 1;
    |     |
    |     help: consider using `let` instead of `static`: `let y`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/issues/issue-35241.stderr b/tests/ui/issues/issue-35241.stderr
index 4a2c15511fe..6f6602793fd 100644
--- a/tests/ui/issues/issue-35241.stderr
+++ b/tests/ui/issues/issue-35241.stderr
@@ -16,6 +16,6 @@ help: use parentheses to construct this tuple struct
 LL | fn test() -> Foo { Foo(/* u32 */) }
    |                       +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-35570.stderr b/tests/ui/issues/issue-35570.stderr
index 197e80ac097..f23b55689e3 100644
--- a/tests/ui/issues/issue-35570.stderr
+++ b/tests/ui/issues/issue-35570.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Trait2<'a> {
    | ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-35976.unimported.stderr b/tests/ui/issues/issue-35976.unimported.stderr
index b31d2a31551..169e3d05d23 100644
--- a/tests/ui/issues/issue-35976.unimported.stderr
+++ b/tests/ui/issues/issue-35976.unimported.stderr
@@ -12,5 +12,5 @@ help: another candidate was found in the following trait, perhaps add a `use` fo
 LL + use private::Future;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-35988.stderr b/tests/ui/issues/issue-35988.stderr
index 55988844c17..4a674b010ea 100644
--- a/tests/ui/issues/issue-35988.stderr
+++ b/tests/ui/issues/issue-35988.stderr
@@ -16,6 +16,6 @@ help: the `Box` type always has a statically known size and allocates its conten
 LL |     V(Box<[Box<E>]>),
    |       ++++        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-36400.stderr b/tests/ui/issues/issue-36400.stderr
index 5b753c69d5d..522fb36e143 100644
--- a/tests/ui/issues/issue-36400.stderr
+++ b/tests/ui/issues/issue-36400.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut x = Box::new(3);
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/issues/issue-3668-2.stderr b/tests/ui/issues/issue-3668-2.stderr
index ba965104154..3676f388891 100644
--- a/tests/ui/issues/issue-3668-2.stderr
+++ b/tests/ui/issues/issue-3668-2.stderr
@@ -6,6 +6,6 @@ LL |     static child: isize = x + 1;
    |     |
    |     help: consider using `let` instead of `static`: `let child`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/issues/issue-3668.stderr b/tests/ui/issues/issue-3668.stderr
index edc49979c10..d761b2d87db 100644
--- a/tests/ui/issues/issue-3668.stderr
+++ b/tests/ui/issues/issue-3668.stderr
@@ -6,6 +6,6 @@ LL |        static childVal: Box<P> = self.child.get();
    |        |
    |        help: consider using `let` instead of `static`: `let childVal`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/issues/issue-3680.stderr b/tests/ui/issues/issue-3680.stderr
index 0b0ae419e2b..2a757b44dc8 100644
--- a/tests/ui/issues/issue-3680.stderr
+++ b/tests/ui/issues/issue-3680.stderr
@@ -13,6 +13,6 @@ help: try wrapping the pattern in `Some`
 LL |         Some(Err(_)) => ()
    |         +++++      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-36836.stderr b/tests/ui/issues/issue-36836.stderr
index 418194fac99..e5c943c7c3d 100644
--- a/tests/ui/issues/issue-36836.stderr
+++ b/tests/ui/issues/issue-36836.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Bar` in this scope
 LL | impl<T> Foo for Bar<T> {}
    |                 ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/issues/issue-3702-2.stderr b/tests/ui/issues/issue-3702-2.stderr
index 0b94c3135a1..4edca796f43 100644
--- a/tests/ui/issues/issue-3702-2.stderr
+++ b/tests/ui/issues/issue-3702-2.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |         Add::to_int(&self) + other.to_int()
    |         ~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/issues/issue-37311-type-length-limit/issue-37311.stderr b/tests/ui/issues/issue-37311-type-length-limit/issue-37311.stderr
index 87832dd29b2..ccee9ed4daa 100644
--- a/tests/ui/issues/issue-37311-type-length-limit/issue-37311.stderr
+++ b/tests/ui/issues/issue-37311-type-length-limit/issue-37311.stderr
@@ -11,5 +11,5 @@ LL |     fn recurse(&self) {
    |     ^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-37311-type-length-limit/issue-37311/issue-37311.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-37665.stderr b/tests/ui/issues/issue-37665.stderr
index 1e1f451b450..2c404b4e744 100644
--- a/tests/ui/issues/issue-37665.stderr
+++ b/tests/ui/issues/issue-37665.stderr
@@ -6,6 +6,6 @@ LL |     let x: () = 0;
    |            |
    |            expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-3779.stderr b/tests/ui/issues/issue-3779.stderr
index a0dbcc920fa..d4f4b79102d 100644
--- a/tests/ui/issues/issue-3779.stderr
+++ b/tests/ui/issues/issue-3779.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     element: Option<Box<S>>
    |                     ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/issues/issue-37884.stderr b/tests/ui/issues/issue-37884.stderr
index 7ddb36c8e6f..633abeb6f22 100644
--- a/tests/ui/issues/issue-37884.stderr
+++ b/tests/ui/issues/issue-37884.stderr
@@ -17,6 +17,6 @@ note: ...does not necessarily outlive the lifetime `'a` as defined here
 LL | impl<'a, T: 'a> Iterator for RepeatMut<'a, T> {
    |      ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-38412.stderr b/tests/ui/issues/issue-38412.stderr
index 610696f84d5..ed8b6b60afc 100644
--- a/tests/ui/issues/issue-38412.stderr
+++ b/tests/ui/issues/issue-38412.stderr
@@ -4,6 +4,6 @@ error[E0532]: cannot match against a tuple struct which contains private fields
 LL |     let Box(a) = loop { };
    |         ^^^ constructor is not visible here due to private fields
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/issues/issue-38458.stderr b/tests/ui/issues/issue-38458.stderr
index c04a01118a4..fbf88d50339 100644
--- a/tests/ui/issues/issue-38458.stderr
+++ b/tests/ui/issues/issue-38458.stderr
@@ -4,6 +4,6 @@ error[E0572]: return statement outside of function body
 LL |     return;
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/issues/issue-38919.stderr b/tests/ui/issues/issue-38919.stderr
index f9ab8a51507..4a4bd2ee43d 100644
--- a/tests/ui/issues/issue-38919.stderr
+++ b/tests/ui/issues/issue-38919.stderr
@@ -6,6 +6,6 @@ LL | fn foo<T: Iterator>() {
 LL |     T::Item;
    |        ^^^^ associated item not found in `T`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-38954.stderr b/tests/ui/issues/issue-38954.stderr
index ab15bb1afa8..4dd83ddf32d 100644
--- a/tests/ui/issues/issue-38954.stderr
+++ b/tests/ui/issues/issue-38954.stderr
@@ -11,6 +11,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn _test(ref _p: &str) {}
    |                  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-39175.stderr b/tests/ui/issues/issue-39175.stderr
index 3a1476ac0e3..1bc11dab327 100644
--- a/tests/ui/issues/issue-39175.stderr
+++ b/tests/ui/issues/issue-39175.stderr
@@ -10,6 +10,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use std::os::unix::process::CommandExt;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-39211.stderr b/tests/ui/issues/issue-39211.stderr
index cd2a014bb68..15c9a80bb35 100644
--- a/tests/ui/issues/issue-39211.stderr
+++ b/tests/ui/issues/issue-39211.stderr
@@ -6,5 +6,5 @@ LL |     let a = [3; M::Row::DIM];
    |
    = note: this may fail depending on what value the parameter takes
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-39687.stderr b/tests/ui/issues/issue-39687.stderr
index b1b3041ea02..f4742115a19 100644
--- a/tests/ui/issues/issue-39687.stderr
+++ b/tests/ui/issues/issue-39687.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     <fn() as Fn()>::call;
    |              ^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/issues/issue-39848.stderr b/tests/ui/issues/issue-39848.stderr
index f98fde43784..a6c6c61f170 100644
--- a/tests/ui/issues/issue-39848.stderr
+++ b/tests/ui/issues/issue-39848.stderr
@@ -21,5 +21,5 @@ help: try placing this code inside a block
 LL |         if $tgt.has_{ $field() } {}
    |                     +          +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-3993.stderr b/tests/ui/issues/issue-3993.stderr
index deecf7a9d75..cf839a13140 100644
--- a/tests/ui/issues/issue-3993.stderr
+++ b/tests/ui/issues/issue-3993.stderr
@@ -10,6 +10,6 @@ note: the function `fly` is defined here
 LL |     fn fly() {}
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/issues/issue-39970.stderr b/tests/ui/issues/issue-39970.stderr
index 713bc404f67..0fe73574bad 100644
--- a/tests/ui/issues/issue-39970.stderr
+++ b/tests/ui/issues/issue-39970.stderr
@@ -18,6 +18,6 @@ LL |     //(): for<'a> Array<'a, Element=&'a ()>, // No ICE
 LL |     (): for<'a> Array<'a, Element=()>, // ICE
    |                           ---------- unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/issues/issue-40288.stderr b/tests/ui/issues/issue-40288.stderr
index db5d064379a..180adcd6e99 100644
--- a/tests/ui/issues/issue-40288.stderr
+++ b/tests/ui/issues/issue-40288.stderr
@@ -10,6 +10,6 @@ LL |     *refr = 3;
 LL |     println!("{:?}", out[0]);
    |                      ------ borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr b/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr
index e15eed65612..7976d090542 100644
--- a/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr
+++ b/tests/ui/issues/issue-40402-ref-hints/issue-40402-1.stderr
@@ -9,6 +9,6 @@ help: consider borrowing here
 LL |     let e = &f.v[0];
    |             +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr b/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr
index 1bc554efb5c..987558903ee 100644
--- a/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr
+++ b/tests/ui/issues/issue-40402-ref-hints/issue-40402-2.stderr
@@ -13,6 +13,6 @@ help: consider borrowing here
 LL |     let (a, b) = &x[0];
    |                  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/issues/issue-40510-1.stderr b/tests/ui/issues/issue-40510-1.stderr
index e88f31ea1ee..81fed1305cb 100644
--- a/tests/ui/issues/issue-40510-1.stderr
+++ b/tests/ui/issues/issue-40510-1.stderr
@@ -15,5 +15,5 @@ LL |         &mut x
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-40510-3.stderr b/tests/ui/issues/issue-40510-3.stderr
index eb077415e6c..43e8a73b819 100644
--- a/tests/ui/issues/issue-40510-3.stderr
+++ b/tests/ui/issues/issue-40510-3.stderr
@@ -19,5 +19,5 @@ help: consider adding 'move' keyword before the nested closure
 LL |         move || {
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-40610.stderr b/tests/ui/issues/issue-40610.stderr
index b4e302dfffc..1bd1c4dd57d 100644
--- a/tests/ui/issues/issue-40610.stderr
+++ b/tests/ui/issues/issue-40610.stderr
@@ -6,6 +6,6 @@ LL |     () + f(&[1.0]);
    |     |
    |     ()
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/issues/issue-40749.stderr b/tests/ui/issues/issue-40749.stderr
index afc39adec46..f7770e00013 100644
--- a/tests/ui/issues/issue-40749.stderr
+++ b/tests/ui/issues/issue-40749.stderr
@@ -7,6 +7,6 @@ LL |     [0; ..10];
    = note: expected type `usize`
             found struct `RangeTo<{integer}>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-40861.stderr b/tests/ui/issues/issue-40861.stderr
index 9b6469d05e9..dec9af4b6d1 100644
--- a/tests/ui/issues/issue-40861.stderr
+++ b/tests/ui/issues/issue-40861.stderr
@@ -6,6 +6,6 @@ LL |     ()[f(&[1.0])];
    |
    = help: to access tuple elements, use tuple indexing syntax (e.g., `tuple.0`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0608`.
diff --git a/tests/ui/issues/issue-41139.stderr b/tests/ui/issues/issue-41139.stderr
index 97492e6e0fa..d7b35245d8f 100644
--- a/tests/ui/issues/issue-41139.stderr
+++ b/tests/ui/issues/issue-41139.stderr
@@ -7,6 +7,6 @@ LL | fn get_function<'a>() -> &'a dyn Fn() -> dyn Trait {
 LL |     let t: &dyn Trait = &get_function()();
    |                          ^^^^^^^^^^^^^^ this trait object returns an unsized value `(dyn Trait + 'static)`, so it cannot be called
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-41229-ref-str.stderr b/tests/ui/issues/issue-41229-ref-str.stderr
index 31fdf3b72e7..afc2cac7343 100644
--- a/tests/ui/issues/issue-41229-ref-str.stderr
+++ b/tests/ui/issues/issue-41229-ref-str.stderr
@@ -11,6 +11,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | pub fn example(ref s: &str) {}
    |                       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-41549.stderr b/tests/ui/issues/issue-41549.stderr
index 62307d387c8..55be59684b5 100644
--- a/tests/ui/issues/issue-41549.stderr
+++ b/tests/ui/issues/issue-41549.stderr
@@ -4,6 +4,6 @@ error[E0326]: implemented const `CONST` has an incompatible type for trait
 LL |     const CONST: () = ();
    |                  ^^ expected `u32`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0326`.
diff --git a/tests/ui/issues/issue-41652/issue-41652.stderr b/tests/ui/issues/issue-41652/issue-41652.stderr
index 1618f0f5a11..a5a2fab2ede 100644
--- a/tests/ui/issues/issue-41652/issue-41652.stderr
+++ b/tests/ui/issues/issue-41652/issue-41652.stderr
@@ -9,6 +9,6 @@ help: you must specify a concrete type for this numeric value, like `i32`
 LL |         3_i32.f()
    |         ~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0689`.
diff --git a/tests/ui/issues/issue-41726.stderr b/tests/ui/issues/issue-41726.stderr
index 7c87fde540d..fe7d4df7067 100644
--- a/tests/ui/issues/issue-41726.stderr
+++ b/tests/ui/issues/issue-41726.stderr
@@ -7,6 +7,6 @@ LL |         things[src.as_str()].sort();
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `HashMap<String, Vec<String>>`
    = help: to modify a `HashMap<String, Vec<String>>`, use `.get_mut()`, `.insert()` or the entry API
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/issues/issue-41742.stderr b/tests/ui/issues/issue-41742.stderr
index 61a0ae5fa91..47c7e5dc11f 100644
--- a/tests/ui/issues/issue-41742.stderr
+++ b/tests/ui/issues/issue-41742.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     H["?"].f();
    |       ^^^ expected `u32`, found `&str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-41880.stderr b/tests/ui/issues/issue-41880.stderr
index 6414e26929a..9d09be66305 100644
--- a/tests/ui/issues/issue-41880.stderr
+++ b/tests/ui/issues/issue-41880.stderr
@@ -7,6 +7,6 @@ LL | pub struct Iterate<T, F> {
 LL |     println!("{:?}", a.iter().take(10).collect::<Vec<usize>>());
    |                        ^^^^ method not found in `Iterate<{integer}, {closure@issue-41880.rs:26:24}>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-42106.stderr b/tests/ui/issues/issue-42106.stderr
index d5a9d233bc9..d5919870d9b 100644
--- a/tests/ui/issues/issue-42106.stderr
+++ b/tests/ui/issues/issue-42106.stderr
@@ -8,6 +8,6 @@ LL |     collection.swap(1, 2);
 LL |     _a.use_ref();
    |     -- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/issues/issue-4265.stderr b/tests/ui/issues/issue-4265.stderr
index 8c7303f3c3c..48b1c762e19 100644
--- a/tests/ui/issues/issue-4265.stderr
+++ b/tests/ui/issues/issue-4265.stderr
@@ -7,6 +7,6 @@ LL |     fn bar() {
 LL |     fn bar() {
    |     ^^^^^^^^ duplicate definitions for `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/issues/issue-42755.stderr b/tests/ui/issues/issue-42755.stderr
index 12047e22f1b..41f6cc97e49 100644
--- a/tests/ui/issues/issue-42755.stderr
+++ b/tests/ui/issues/issue-42755.stderr
@@ -4,5 +4,5 @@ error: repetition matches empty token tree
 LL |     ($($p:vis)*) => {}
    |       ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-42796.stderr b/tests/ui/issues/issue-42796.stderr
index f2971df5db2..670b98c7708 100644
--- a/tests/ui/issues/issue-42796.stderr
+++ b/tests/ui/issues/issue-42796.stderr
@@ -15,6 +15,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     let mut s_copy = s.clone();
    |                       ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/issues/issue-42880.stderr b/tests/ui/issues/issue-42880.stderr
index bec14429d38..f174f42b239 100644
--- a/tests/ui/issues/issue-42880.stderr
+++ b/tests/ui/issues/issue-42880.stderr
@@ -4,6 +4,6 @@ error[E0599]: no associated item named `String` found for struct `String` in the
 LL |     let f = |&Value::String(_)| ();
    |                      ^^^^^^ associated item not found in `String`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-4335.stderr b/tests/ui/issues/issue-4335.stderr
index ecc1fa52398..8b4aff54dc3 100644
--- a/tests/ui/issues/issue-4335.stderr
+++ b/tests/ui/issues/issue-4335.stderr
@@ -8,6 +8,6 @@ LL |     id(Box::new(|| *v))
    |                 |
    |                 captured by this `FnMut` closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/issues/issue-43355.stderr b/tests/ui/issues/issue-43355.stderr
index 9aeca8efe4a..25179ef6a96 100644
--- a/tests/ui/issues/issue-43355.stderr
+++ b/tests/ui/issues/issue-43355.stderr
@@ -9,6 +9,6 @@ LL | impl<X> Trait1<Box<X>> for A {
    |
    = note: downstream crates may implement trait `Trait2<std::boxed::Box<_>>` for type `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/issues/issue-43420-no-over-suggest.stderr b/tests/ui/issues/issue-43420-no-over-suggest.stderr
index 9b141e2bf99..3da8cc7288d 100644
--- a/tests/ui/issues/issue-43420-no-over-suggest.stderr
+++ b/tests/ui/issues/issue-43420-no-over-suggest.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn foo(b: &[u16]) {}
    |    ^^^ ---------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-43424.stderr b/tests/ui/issues/issue-43424.stderr
index 8f59d7cc3aa..64a3c2a3d8d 100644
--- a/tests/ui/issues/issue-43424.stderr
+++ b/tests/ui/issues/issue-43424.stderr
@@ -4,5 +4,5 @@ error: unexpected generic arguments in path
 LL | m!(inline<u8>);
    |          ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-43431.stderr b/tests/ui/issues/issue-43431.stderr
index 4edb528699d..6d47ba27162 100644
--- a/tests/ui/issues/issue-43431.stderr
+++ b/tests/ui/issues/issue-43431.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |         <Self as Fn(A) -> B>::call(self, (a,))
    |                           ^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/issues/issue-43925.stderr b/tests/ui/issues/issue-43925.stderr
index b0ad25063de..7cc347c6163 100644
--- a/tests/ui/issues/issue-43925.stderr
+++ b/tests/ui/issues/issue-43925.stderr
@@ -4,5 +4,5 @@ error: link cfg must have a single predicate argument
 LL | #[link(name = "foo", cfg("rlib"))]
    |                      ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-43926.stderr b/tests/ui/issues/issue-43926.stderr
index f67f91a6bd3..7c5c50a38a9 100644
--- a/tests/ui/issues/issue-43926.stderr
+++ b/tests/ui/issues/issue-43926.stderr
@@ -4,5 +4,5 @@ error: link cfg must have a single predicate argument
 LL | #[link(name = "foo", cfg())]
    |                      ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-44023.stderr b/tests/ui/issues/issue-44023.stderr
index 9e97012416a..8554154fba5 100644
--- a/tests/ui/issues/issue-44023.stderr
+++ b/tests/ui/issues/issue-44023.stderr
@@ -6,6 +6,6 @@ LL | fn საჭმელად_გემრიელი_სადილი ( )
    |    |
    |    implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-44078.stderr b/tests/ui/issues/issue-44078.stderr
index daf67219f4d..3e12de34e11 100644
--- a/tests/ui/issues/issue-44078.stderr
+++ b/tests/ui/issues/issue-44078.stderr
@@ -6,6 +6,6 @@ LL |       "😊"";
 LL | | }
    | |__^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0765`.
diff --git a/tests/ui/issues/issue-44239.stderr b/tests/ui/issues/issue-44239.stderr
index 2a245c92c48..633fb177b75 100644
--- a/tests/ui/issues/issue-44239.stderr
+++ b/tests/ui/issues/issue-44239.stderr
@@ -7,6 +7,6 @@ LL |     let n: usize = 0;
 LL |         const N: usize = n;
    |                          ^ non-constant value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/issues/issue-44405.stderr b/tests/ui/issues/issue-44405.stderr
index 1fd69f6e777..26d2b385efa 100644
--- a/tests/ui/issues/issue-44405.stderr
+++ b/tests/ui/issues/issue-44405.stderr
@@ -6,6 +6,6 @@ LL |     container[&mut val].test();
    |
    = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `Container`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/issues/issue-4517.stderr b/tests/ui/issues/issue-4517.stderr
index 78ee336f19a..5d544ee10a9 100644
--- a/tests/ui/issues/issue-4517.stderr
+++ b/tests/ui/issues/issue-4517.stderr
@@ -12,6 +12,6 @@ note: function defined here
 LL | fn bar(int_param: usize) {}
    |    ^^^ ----------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-45562.stderr b/tests/ui/issues/issue-45562.stderr
index be259d3f8a4..6fae86f9f31 100644
--- a/tests/ui/issues/issue-45562.stderr
+++ b/tests/ui/issues/issue-45562.stderr
@@ -8,5 +8,5 @@ LL | #[no_mangle] pub const RAH: usize = 5;
    |
    = note: `#[deny(no_mangle_const_items)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-45801.stderr b/tests/ui/issues/issue-45801.stderr
index e651e2a68d1..5a10c429564 100644
--- a/tests/ui/issues/issue-45801.stderr
+++ b/tests/ui/issues/issue-45801.stderr
@@ -7,6 +7,6 @@ LL |     req.get_ref::<Params>();
    = help: the trait `Plugin<Foo>` is implemented for `Params`
    = help: for that trait implementation, expected `Foo`, found `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-45965.stderr b/tests/ui/issues/issue-45965.stderr
index f3eaa91769f..95a39b1d198 100644
--- a/tests/ui/issues/issue-45965.stderr
+++ b/tests/ui/issues/issue-45965.stderr
@@ -6,6 +6,6 @@ LL |     let a = |r: f64| if r != 0.0(r != 0.0) { 1.0 } else { 0.0 };
    |                              |
    |                              call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-46302.stderr b/tests/ui/issues/issue-46302.stderr
index 6e126038cc9..e87c17b2ad3 100644
--- a/tests/ui/issues/issue-46302.stderr
+++ b/tests/ui/issues/issue-46302.stderr
@@ -9,6 +9,6 @@ help: consider borrowing here
 LL |   let u: &str = if true { &s[..2] } else { s };
    |                           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-46311.stderr b/tests/ui/issues/issue-46311.stderr
index d72d6477db6..86a3602899a 100644
--- a/tests/ui/issues/issue-46311.stderr
+++ b/tests/ui/issues/issue-46311.stderr
@@ -4,5 +4,5 @@ error: invalid label name `'break`
 LL |     'break: loop {
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-46332.stderr b/tests/ui/issues/issue-46332.stderr
index 890ef8014b4..8c0c1dfa6ee 100644
--- a/tests/ui/issues/issue-46332.stderr
+++ b/tests/ui/issues/issue-46332.stderr
@@ -7,6 +7,6 @@ LL | struct TyUint {}
 LL |     TyUInt {};
    |     ^^^^^^ help: a struct with a similar name exists (notice the capitalization): `TyUint`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/issues/issue-46438.stderr b/tests/ui/issues/issue-46438.stderr
index c1fad44b885..aff2d77a0c8 100644
--- a/tests/ui/issues/issue-46438.stderr
+++ b/tests/ui/issues/issue-46438.stderr
@@ -4,5 +4,5 @@ error: expected a trait, found type
 LL | m!(&'static u8);
    |    ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-46471-1.stderr b/tests/ui/issues/issue-46471-1.stderr
index 2ae6e709d5a..d4517223982 100644
--- a/tests/ui/issues/issue-46471-1.stderr
+++ b/tests/ui/issues/issue-46471-1.stderr
@@ -8,6 +8,6 @@ LL |         &mut z
 LL |     };
    |     - `z` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/issues/issue-46472.stderr b/tests/ui/issues/issue-46472.stderr
index 6e561e03a8b..6115da28cc9 100644
--- a/tests/ui/issues/issue-46472.stderr
+++ b/tests/ui/issues/issue-46472.stderr
@@ -7,6 +7,6 @@ LL |     &mut 4
    |     |    temporary value created here
    |     returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/issues/issue-46771.stderr b/tests/ui/issues/issue-46771.stderr
index 512827b2dbd..fab55fbfd70 100644
--- a/tests/ui/issues/issue-46771.stderr
+++ b/tests/ui/issues/issue-46771.stderr
@@ -8,6 +8,6 @@ LL |     (1 .. 2).find(|_| Foo(0) == 0);
    |                       |
    |                       call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/issues/issue-46983.stderr b/tests/ui/issues/issue-46983.stderr
index 38a219bbd7b..f47df306ab8 100644
--- a/tests/ui/issues/issue-46983.stderr
+++ b/tests/ui/issues/issue-46983.stderr
@@ -6,5 +6,5 @@ LL | fn foo(x: &u32) -> &'static u32 {
 LL |     &*x
    |     ^^^ returning this value requires that `'1` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-47184.stderr b/tests/ui/issues/issue-47184.stderr
index c2c7df7a333..d25c6eda9c3 100644
--- a/tests/ui/issues/issue-47184.stderr
+++ b/tests/ui/issues/issue-47184.stderr
@@ -7,6 +7,6 @@ LL |     let _vec: Vec<&'static String> = vec![&String::new()];
    |               |                            creates a temporary value which is freed while still in use
    |               type annotation requires that borrow lasts for `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/issues/issue-4736.stderr b/tests/ui/issues/issue-4736.stderr
index 2a1f1819c33..146dd1d57ce 100644
--- a/tests/ui/issues/issue-4736.stderr
+++ b/tests/ui/issues/issue-4736.stderr
@@ -12,6 +12,6 @@ help: `NonCopyable` is a tuple struct, use the appropriate syntax
 LL |     let z = NonCopyable(/* fields */);
    |             ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/issues/issue-47377.stderr b/tests/ui/issues/issue-47377.stderr
index 4f0fd948e76..12e5c15d77f 100644
--- a/tests/ui/issues/issue-47377.stderr
+++ b/tests/ui/issues/issue-47377.stderr
@@ -13,6 +13,6 @@ help: create an owned `String` from a string reference
 LL |      let _a = b.to_owned() + ", World!";
    |                +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/issues/issue-47380.stderr b/tests/ui/issues/issue-47380.stderr
index b04ac5536c4..4fca0296e43 100644
--- a/tests/ui/issues/issue-47380.stderr
+++ b/tests/ui/issues/issue-47380.stderr
@@ -13,6 +13,6 @@ help: create an owned `String` from a string reference
 LL |     println!("🦀🦀🦀🦀🦀"); let _a = b.to_owned() + ", World!";
    |                                       +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/issues/issue-47725.stderr b/tests/ui/issues/issue-47725.stderr
index 7143fb4d6e1..0d3b77b4608 100644
--- a/tests/ui/issues/issue-47725.stderr
+++ b/tests/ui/issues/issue-47725.stderr
@@ -56,5 +56,5 @@ help: try `#[link(name = "...")]` instead
 LL | #[link_name]
    | ^^^^^^^^^^^^
 
-error: aborting due to previous error; 3 warnings emitted
+error: aborting due to 1 previous error; 3 warnings emitted
 
diff --git a/tests/ui/issues/issue-48364.stderr b/tests/ui/issues/issue-48364.stderr
index 3f2e1b83ad5..74bfa1e0693 100644
--- a/tests/ui/issues/issue-48364.stderr
+++ b/tests/ui/issues/issue-48364.stderr
@@ -11,6 +11,6 @@ LL |     b"".starts_with(stringify!(foo))
 note: method defined here
   --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-48728.stderr b/tests/ui/issues/issue-48728.stderr
index 0bb46724f61..6b4247f1d79 100644
--- a/tests/ui/issues/issue-48728.stderr
+++ b/tests/ui/issues/issue-48728.stderr
@@ -10,6 +10,6 @@ LL | impl<T: Clone + ?Sized> Clone for Node<[T]> {
    = note: upstream crates may add a new impl of trait `std::clone::Clone` for type `[_]` in future versions
    = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/issues/issue-48838.stderr b/tests/ui/issues/issue-48838.stderr
index 159199a7fce..504ea3e8010 100644
--- a/tests/ui/issues/issue-48838.stderr
+++ b/tests/ui/issues/issue-48838.stderr
@@ -7,6 +7,6 @@ LL |     Square = |x| x,
    = note: expected type `isize`
            found closure `{closure@$DIR/issue-48838.rs:2:14: 2:17}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-4935.stderr b/tests/ui/issues/issue-4935.stderr
index e544e424403..25f299ae5f3 100644
--- a/tests/ui/issues/issue-4935.stderr
+++ b/tests/ui/issues/issue-4935.stderr
@@ -13,6 +13,6 @@ note: function defined here
 LL | fn foo(a: usize) {}
    |    ^^^ --------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/issues/issue-4968.stderr b/tests/ui/issues/issue-4968.stderr
index 1ce0333846f..549e5509474 100644
--- a/tests/ui/issues/issue-4968.stderr
+++ b/tests/ui/issues/issue-4968.stderr
@@ -15,6 +15,6 @@ LL |     match 42 { A => () }
    = note: expected type `{integer}`
              found tuple `(isize, isize)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-4972.stderr b/tests/ui/issues/issue-4972.stderr
index 83daded7e09..8de3909ca30 100644
--- a/tests/ui/issues/issue-4972.stderr
+++ b/tests/ui/issues/issue-4972.stderr
@@ -4,6 +4,6 @@ error[E0033]: type `Box<(dyn MyTrait + 'static)>` cannot be dereferenced
 LL |         TraitWrapper::A(box ref map) => map,
    |                         ^^^^^^^^^^^ type `Box<(dyn MyTrait + 'static)>` cannot be dereferenced
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0033`.
diff --git a/tests/ui/issues/issue-49824.stderr b/tests/ui/issues/issue-49824.stderr
index 14beadececb..1c77090de27 100644
--- a/tests/ui/issues/issue-49824.stderr
+++ b/tests/ui/issues/issue-49824.stderr
@@ -19,5 +19,5 @@ help: consider adding 'move' keyword before the nested closure
 LL |         move || {
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-49919.stderr b/tests/ui/issues/issue-49919.stderr
index 8098be5cc45..597d76fc27b 100644
--- a/tests/ui/issues/issue-49919.stderr
+++ b/tests/ui/issues/issue-49919.stderr
@@ -4,6 +4,6 @@ error[E0582]: binding for associated type `Output` references lifetime `'c`, whi
 LL |     let foo: Box<dyn for <'c> Fn() -> &'c T> = Box::new(move || &t);
    |                                       ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0582`.
diff --git a/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref.stderr b/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref.stderr
index ce8173169b1..84247a42704 100644
--- a/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref.stderr
+++ b/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref.stderr
@@ -7,6 +7,6 @@ LL |     let _result = &Some(42).as_deref();
    = note: the following trait bounds were not satisfied:
            `{integer}: Deref`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr b/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr
index 943f7748696..bf05ab5665c 100644
--- a/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr
+++ b/tests/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr
@@ -7,6 +7,6 @@ LL |     let _result = &mut Some(42).as_deref_mut();
    = note: the following trait bounds were not satisfied:
            `{integer}: Deref`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr b/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr
index a3b9ac67758..ac744a6d3b6 100644
--- a/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr
+++ b/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref.stderr
@@ -7,6 +7,6 @@ LL |     let _result = &Ok(42).as_deref();
    = note: the following trait bounds were not satisfied:
            `{integer}: Deref`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr b/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr
index aa771e4c04e..688d2cf3486 100644
--- a/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr
+++ b/tests/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr
@@ -7,6 +7,6 @@ LL |     let _result = &mut Ok(42).as_deref_mut();
    = note: the following trait bounds were not satisfied:
            `{integer}: Deref`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-50403.stderr b/tests/ui/issues/issue-50403.stderr
index d50befa5e32..193d815d519 100644
--- a/tests/ui/issues/issue-50403.stderr
+++ b/tests/ui/issues/issue-50403.stderr
@@ -4,5 +4,5 @@ error: `concat_idents!()` takes 1 or more arguments
 LL |     let x = concat_idents!();
    |             ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-50571.stderr b/tests/ui/issues/issue-50571.stderr
index f69963bb7af..fe47790f1dd 100644
--- a/tests/ui/issues/issue-50571.stderr
+++ b/tests/ui/issues/issue-50571.stderr
@@ -9,6 +9,6 @@ help: give this argument a name or use an underscore to ignore it
 LL |     fn foo(_: [i32; 2]) {}
    |            ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0642`.
diff --git a/tests/ui/issues/issue-50581.stderr b/tests/ui/issues/issue-50581.stderr
index 07b6df072cb..bac1ade3b0c 100644
--- a/tests/ui/issues/issue-50581.stderr
+++ b/tests/ui/issues/issue-50581.stderr
@@ -4,6 +4,6 @@ error[E0268]: `break` outside of a loop or labeled block
 LL |     |_: [u8; break]| ();
    |              ^^^^^ cannot `break` outside of a loop or labeled block
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0268`.
diff --git a/tests/ui/issues/issue-50600.stderr b/tests/ui/issues/issue-50600.stderr
index d285c3467ab..e3ae7f144c3 100644
--- a/tests/ui/issues/issue-50600.stderr
+++ b/tests/ui/issues/issue-50600.stderr
@@ -7,6 +7,6 @@ LL |     fn([u8; |x: u8| {}]),
    = note: expected type `usize`
            found closure `{closure@$DIR/issue-50600.rs:2:13: 2:20}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-50618.stderr b/tests/ui/issues/issue-50618.stderr
index 1ac5dde66e9..1a3514fb715 100644
--- a/tests/ui/issues/issue-50618.stderr
+++ b/tests/ui/issues/issue-50618.stderr
@@ -6,6 +6,6 @@ LL |             nonexistent: 0,
    |
    = note: available fields are: `x`, `y`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/issues/issue-5062.stderr b/tests/ui/issues/issue-5062.stderr
index 3191bd3de32..0839ece79aa 100644
--- a/tests/ui/issues/issue-5062.stderr
+++ b/tests/ui/issues/issue-5062.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL | fn main() { format!("{:?}", None::<T>); }
    |                                 +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-50688.stderr b/tests/ui/issues/issue-50688.stderr
index df7603d7974..873f179f56d 100644
--- a/tests/ui/issues/issue-50688.stderr
+++ b/tests/ui/issues/issue-50688.stderr
@@ -7,6 +7,6 @@ LL |     [1; || {}];
    = note: expected type `usize`
            found closure `{closure@$DIR/issue-50688.rs:2:9: 2:11}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-50714-1.stderr b/tests/ui/issues/issue-50714-1.stderr
index bacd09b2ae1..7593ac38346 100644
--- a/tests/ui/issues/issue-50714-1.stderr
+++ b/tests/ui/issues/issue-50714-1.stderr
@@ -4,6 +4,6 @@ error[E0647]: `#[start]` function is not allowed to have a `where` clause
 LL | fn start(_: isize, _: *const *const u8) -> isize where fn(&()): Eq {
    |                                                  ^^^^^^^^^^^^^^^^^ `#[start]` function cannot have a `where` clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0647`.
diff --git a/tests/ui/issues/issue-50714.stderr b/tests/ui/issues/issue-50714.stderr
index a11aceb6211..57f9769d1dd 100644
--- a/tests/ui/issues/issue-50714.stderr
+++ b/tests/ui/issues/issue-50714.stderr
@@ -4,6 +4,6 @@ error[E0646]: `main` function is not allowed to have a `where` clause
 LL | fn main() where fn(&()): Eq {}
    |           ^^^^^^^^^^^^^^^^^ `main` cannot have a `where` clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0646`.
diff --git a/tests/ui/issues/issue-50781.stderr b/tests/ui/issues/issue-50781.stderr
index e185ecdda23..beaea1e634c 100644
--- a/tests/ui/issues/issue-50781.stderr
+++ b/tests/ui/issues/issue-50781.stderr
@@ -20,5 +20,5 @@ note: the lint level is defined here
 LL | #![deny(where_clauses_object_safety)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-50802.stderr b/tests/ui/issues/issue-50802.stderr
index e064fabccd0..e1b5ae32512 100644
--- a/tests/ui/issues/issue-50802.stderr
+++ b/tests/ui/issues/issue-50802.stderr
@@ -4,6 +4,6 @@ error[E0590]: `break` or `continue` with no label in the condition of a `while`
 LL |         break while continue {
    |                     ^^^^^^^^ unlabeled `continue` in the condition of a `while` loop
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0590`.
diff --git a/tests/ui/issues/issue-51022.stderr b/tests/ui/issues/issue-51022.stderr
index 5e196bd4e25..c02c0ac93fa 100644
--- a/tests/ui/issues/issue-51022.stderr
+++ b/tests/ui/issues/issue-51022.stderr
@@ -4,6 +4,6 @@ error[E0131]: `main` function is not allowed to have generic parameters
 LL | fn main<'a>() { }
    |        ^^^^ `main` cannot have generic parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0131`.
diff --git a/tests/ui/issues/issue-51116.stderr b/tests/ui/issues/issue-51116.stderr
index c07f8735eb2..4839a0d4609 100644
--- a/tests/ui/issues/issue-51116.stderr
+++ b/tests/ui/issues/issue-51116.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |             *tile = 0;
    |             ^^^^^ cannot infer type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/issues/issue-51154.stderr b/tests/ui/issues/issue-51154.stderr
index 5ae8e067807..b7451ea28ee 100644
--- a/tests/ui/issues/issue-51154.stderr
+++ b/tests/ui/issues/issue-51154.stderr
@@ -14,6 +14,6 @@ LL |     let _: Box<F> = Box::new(|| ());
 note: associated function defined here
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-5153.stderr b/tests/ui/issues/issue-5153.stderr
index 93aaf4b9d82..53c140b5b6d 100644
--- a/tests/ui/issues/issue-5153.stderr
+++ b/tests/ui/issues/issue-5153.stderr
@@ -7,6 +7,6 @@ LL |     fn foo(self: Box<Self>);
 LL |     (&5isize as &dyn Foo).foo();
    |                           ^^^ method not found in `&dyn Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-51632-try-desugar-incompatible-types.stderr b/tests/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
index c92da53dbc4..99fce1eeea6 100644
--- a/tests/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
+++ b/tests/ui/issues/issue-51632-try-desugar-incompatible-types.stderr
@@ -19,6 +19,6 @@ help: try wrapping the expression in `Ok`
 LL |     Ok(missing_discourses()?)
    |     +++                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-51874.stderr b/tests/ui/issues/issue-51874.stderr
index b39159a6539..5be3695dd45 100644
--- a/tests/ui/issues/issue-51874.stderr
+++ b/tests/ui/issues/issue-51874.stderr
@@ -9,6 +9,6 @@ help: you must specify a concrete type for this numeric value, like `f32`
 LL |     let a = (1.0_f32).pow(1.0);
    |              ~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0689`.
diff --git a/tests/ui/issues/issue-52049.stderr b/tests/ui/issues/issue-52049.stderr
index 0812976cf40..1d8e136f217 100644
--- a/tests/ui/issues/issue-52049.stderr
+++ b/tests/ui/issues/issue-52049.stderr
@@ -7,6 +7,6 @@ LL |     foo(&unpromotable(5u32));
    |     |    creates a temporary value which is freed while still in use
    |     argument requires that borrow lasts for `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/issues/issue-52126-assign-op-invariance.stderr b/tests/ui/issues/issue-52126-assign-op-invariance.stderr
index 316e755f42a..af9553e5cf3 100644
--- a/tests/ui/issues/issue-52126-assign-op-invariance.stderr
+++ b/tests/ui/issues/issue-52126-assign-op-invariance.stderr
@@ -12,6 +12,6 @@ LL |         acc += cnt2;
 LL |     }
    |     - `line` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/issues/issue-52262.stderr b/tests/ui/issues/issue-52262.stderr
index ef41f078b80..ce8e6fe2bf8 100644
--- a/tests/ui/issues/issue-52262.stderr
+++ b/tests/ui/issues/issue-52262.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of `*key` which is behind a shared reference
 LL |                 String::from_utf8(*key).unwrap()
    |                                   ^^^^ move occurs because `*key` has type `Vec<u8>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/issues/issue-5239-1.stderr b/tests/ui/issues/issue-5239-1.stderr
index f53ddb95416..63c2dbfc55c 100644
--- a/tests/ui/issues/issue-5239-1.stderr
+++ b/tests/ui/issues/issue-5239-1.stderr
@@ -6,6 +6,6 @@ LL |     let x = |ref x: isize| { x += 1; };
    |                              |
    |                              cannot use `+=` on type `&isize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0368`.
diff --git a/tests/ui/issues/issue-52489.stderr b/tests/ui/issues/issue-52489.stderr
index 842ebd19698..442902bd1c3 100644
--- a/tests/ui/issues/issue-52489.stderr
+++ b/tests/ui/issues/issue-52489.stderr
@@ -6,6 +6,6 @@ LL | use issue_52489;
    |
    = help: add `#![feature(issue_52489_unstable)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/issues/issue-52533.stderr b/tests/ui/issues/issue-52533.stderr
index c764736d798..8b56b36d39b 100644
--- a/tests/ui/issues/issue-52533.stderr
+++ b/tests/ui/issues/issue-52533.stderr
@@ -7,5 +7,5 @@ LL |     foo(|a, b| b)
    |          |  has type `&'1 u32`
    |          has type `&'2 u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-52717.stderr b/tests/ui/issues/issue-52717.stderr
index 468cdf2dcf9..ab8c37225ca 100644
--- a/tests/ui/issues/issue-52717.stderr
+++ b/tests/ui/issues/issue-52717.stderr
@@ -7,6 +7,6 @@ LL |     A::A { fob } => { println!("{}", fob); }
    |            variant `A::A` does not have this field
    |            help: a field with a similar name exists: `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0026`.
diff --git a/tests/ui/issues/issue-53300.stderr b/tests/ui/issues/issue-53300.stderr
index 2fedef7d23d..293465ecb81 100644
--- a/tests/ui/issues/issue-53300.stderr
+++ b/tests/ui/issues/issue-53300.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Wrapper` in this scope
 LL | fn addition() -> Wrapper<impl A> {}
    |                  ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/issues/issue-53348.stderr b/tests/ui/issues/issue-53348.stderr
index e4cdb7e889b..38fa98e65e1 100644
--- a/tests/ui/issues/issue-53348.stderr
+++ b/tests/ui/issues/issue-53348.stderr
@@ -7,6 +7,6 @@ LL |     for i in v {
 LL |         a = *i.to_string();
    |             ^^^^^^^^^^^^^^ expected `String`, found `str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-53498.stderr b/tests/ui/issues/issue-53498.stderr
index b28fbff62b9..61a1aedf508 100644
--- a/tests/ui/issues/issue-53498.stderr
+++ b/tests/ui/issues/issue-53498.stderr
@@ -7,6 +7,6 @@ LL |         fn foo() {}
 LL |     test::Foo::<test::B>::foo();
    |                           ^^^ private associated function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/issues/issue-5358-1.stderr b/tests/ui/issues/issue-5358-1.stderr
index 059462a363e..1bb946ce4cb 100644
--- a/tests/ui/issues/issue-5358-1.stderr
+++ b/tests/ui/issues/issue-5358-1.stderr
@@ -17,6 +17,6 @@ help: you might have meant to use field `0` whose type is `Either<usize, usize>`
 LL |     match S(Either::Left(5)).0 {
    |           ~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-54062.stderr b/tests/ui/issues/issue-54062.stderr
index 5361ee1d345..75eef543f27 100644
--- a/tests/ui/issues/issue-54062.stderr
+++ b/tests/ui/issues/issue-54062.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `inner` of struct `Mutex` is private
 LL |     let _ = test.comps.inner.try_lock();
    |                        ^^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/issues/issue-5439.stderr b/tests/ui/issues/issue-5439.stderr
index a91e4b31f4b..6d1d74e3045 100644
--- a/tests/ui/issues/issue-5439.stderr
+++ b/tests/ui/issues/issue-5439.stderr
@@ -6,6 +6,6 @@ LL |         return Box::new(Foo { nonexistent: self, foo: i });
    |
    = note: all struct fields are already assigned
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/issues/issue-54410.stderr b/tests/ui/issues/issue-54410.stderr
index 516c59afb33..97e5990750e 100644
--- a/tests/ui/issues/issue-54410.stderr
+++ b/tests/ui/issues/issue-54410.stderr
@@ -6,6 +6,6 @@ LL |     pub static mut symbol: [i8];
    |
    = help: the trait `Sized` is not implemented for `[i8]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-55587.stderr b/tests/ui/issues/issue-55587.stderr
index faf78cfe8d9..eec6426a299 100644
--- a/tests/ui/issues/issue-55587.stderr
+++ b/tests/ui/issues/issue-55587.stderr
@@ -6,6 +6,6 @@ LL |     let Path::new();
    |
    = help: for more information, visit https://doc.rust-lang.org/book/ch18-00-patterns.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0164`.
diff --git a/tests/ui/issues/issue-55731.stderr b/tests/ui/issues/issue-55731.stderr
index 97fd6678c99..2c38041642d 100644
--- a/tests/ui/issues/issue-55731.stderr
+++ b/tests/ui/issues/issue-55731.stderr
@@ -10,5 +10,5 @@ LL | |     });
    = note: `DistributedIteratorMulti<&'0 ()>` would have to be implemented for the type `Cloned<&()>`, for any lifetime `'0`...
    = note: ...but `DistributedIteratorMulti<&'1 ()>` is actually implemented for the type `Cloned<&'1 ()>`, for some specific lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-56806.stderr b/tests/ui/issues/issue-56806.stderr
index f164fd0c5d2..f3d4c2fef94 100644
--- a/tests/ui/issues/issue-56806.stderr
+++ b/tests/ui/issues/issue-56806.stderr
@@ -7,6 +7,6 @@ LL |     fn dyn_instead_of_self(self: Box<dyn Trait>);
    = note: type of `self` must be `Self` or a type that dereferences to it
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0307`.
diff --git a/tests/ui/issues/issue-56943.stderr b/tests/ui/issues/issue-56943.stderr
index c394e620b82..60a2e92dc71 100644
--- a/tests/ui/issues/issue-56943.stderr
+++ b/tests/ui/issues/issue-56943.stderr
@@ -6,6 +6,6 @@ LL |     let _: issue_56943::S = issue_56943::S2;
    |            |
    |            expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-57271.stderr b/tests/ui/issues/issue-57271.stderr
index 391e69c91fb..10cbb34ef5d 100644
--- a/tests/ui/issues/issue-57271.stderr
+++ b/tests/ui/issues/issue-57271.stderr
@@ -22,6 +22,6 @@ LL |     Base(BaseType),
 LL ~     Object(Box<ObjectType>),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/issues/issue-57362-1.stderr b/tests/ui/issues/issue-57362-1.stderr
index b10273f14bd..79b1b131afa 100644
--- a/tests/ui/issues/issue-57362-1.stderr
+++ b/tests/ui/issues/issue-57362-1.stderr
@@ -11,6 +11,6 @@ note: `Trait` defines an item `f`, perhaps you need to implement it
 LL | trait Trait {
    | ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-57362-2.stderr b/tests/ui/issues/issue-57362-2.stderr
index 37beb587d27..57477f5341e 100644
--- a/tests/ui/issues/issue-57362-2.stderr
+++ b/tests/ui/issues/issue-57362-2.stderr
@@ -13,6 +13,6 @@ note: `X` defines an item `make_g`, perhaps you need to implement it
 LL | trait X {
    | ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-57924.stderr b/tests/ui/issues/issue-57924.stderr
index 0323a4dfb8a..40435fd0f0a 100644
--- a/tests/ui/issues/issue-57924.stderr
+++ b/tests/ui/issues/issue-57924.stderr
@@ -6,6 +6,6 @@ LL |         Self::<E>(e)
    |         |
    |         not allowed on self constructor
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/issues/issue-5844.mir.stderr b/tests/ui/issues/issue-5844.mir.stderr
index 6134d6889ff..4434f5a0ff2 100644
--- a/tests/ui/issues/issue-5844.mir.stderr
+++ b/tests/ui/issues/issue-5844.mir.stderr
@@ -6,6 +6,6 @@ LL |     issue_5844_aux::rand();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/issues/issue-5844.thir.stderr b/tests/ui/issues/issue-5844.thir.stderr
index 310a2b593fe..6074f7d0ed4 100644
--- a/tests/ui/issues/issue-5844.thir.stderr
+++ b/tests/ui/issues/issue-5844.thir.stderr
@@ -6,6 +6,6 @@ LL |     issue_5844_aux::rand();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/issues/issue-58734.stderr b/tests/ui/issues/issue-58734.stderr
index d2314626d3e..5ae1ec7cac8 100644
--- a/tests/ui/issues/issue-58734.stderr
+++ b/tests/ui/issues/issue-58734.stderr
@@ -18,6 +18,6 @@ error[E0599]: no function or associated item named `nonexistent` found for trait
 LL |     Trait::nonexistent(());
    |            ^^^^^^^^^^^ function or associated item not found in `dyn Trait`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-5883.stderr b/tests/ui/issues/issue-5883.stderr
index a3e2531b5ca..51d9708e0fa 100644
--- a/tests/ui/issues/issue-5883.stderr
+++ b/tests/ui/issues/issue-5883.stderr
@@ -15,6 +15,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL |     r: &dyn A + 'static
    |        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-58857.stderr b/tests/ui/issues/issue-58857.stderr
index 6aef35f0bb9..ac70bc725e2 100644
--- a/tests/ui/issues/issue-58857.stderr
+++ b/tests/ui/issues/issue-58857.stderr
@@ -4,5 +4,5 @@ error: negative bounds are not supported
 LL | impl<A: !Valid> Conj<A>{}
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-59494.stderr b/tests/ui/issues/issue-59494.stderr
index e9a4bf96741..960de1be299 100644
--- a/tests/ui/issues/issue-59494.stderr
+++ b/tests/ui/issues/issue-59494.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `t8n`
 LL | fn t8n<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(A) -> C) -> impl Fn(A) -> (B, C)
    |                                             ^^^^^^^^^^ required by this bound in `t8n`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-5997-enum.stderr b/tests/ui/issues/issue-5997-enum.stderr
index d07258ea7a2..c0b3cd6de66 100644
--- a/tests/ui/issues/issue-5997-enum.stderr
+++ b/tests/ui/issues/issue-5997-enum.stderr
@@ -8,6 +8,6 @@ LL |     enum E { V(Z) }
    |           |
    |           help: try introducing a local generic parameter here: `<Z>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/issues/issue-5997-struct.stderr b/tests/ui/issues/issue-5997-struct.stderr
index 83229e02c6c..670a54894b5 100644
--- a/tests/ui/issues/issue-5997-struct.stderr
+++ b/tests/ui/issues/issue-5997-struct.stderr
@@ -8,6 +8,6 @@ LL |     struct S(T);
    |             |
    |             help: try introducing a local generic parameter here: `<T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/issues/issue-60218.stderr b/tests/ui/issues/issue-60218.stderr
index ae3c4d12025..b9317621b77 100644
--- a/tests/ui/issues/issue-60218.stderr
+++ b/tests/ui/issues/issue-60218.stderr
@@ -20,6 +20,6 @@ LL | pub fn trigger_error<I, F>(iterable: I, functor: F)
 LL | for<'t> <Map<<&'t I as IntoIterator>::IntoIter, F> as Iterator>::Item: Foo,
    |                                                                        ^^^ required by this bound in `trigger_error`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-61106.stderr b/tests/ui/issues/issue-61106.stderr
index aa922e2682d..f825141fa06 100644
--- a/tests/ui/issues/issue-61106.stderr
+++ b/tests/ui/issues/issue-61106.stderr
@@ -16,6 +16,6 @@ help: consider borrowing here
 LL |     foo(&x.clone());
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-61108.stderr b/tests/ui/issues/issue-61108.stderr
index dd87b62664b..d018986efec 100644
--- a/tests/ui/issues/issue-61108.stderr
+++ b/tests/ui/issues/issue-61108.stderr
@@ -16,6 +16,6 @@ help: consider iterating over a slice of the `Vec<char>`'s content to avoid movi
 LL |     for l in &bad_letters {
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/issues/issue-61623.stderr b/tests/ui/issues/issue-61623.stderr
index bedea3890a3..be6e28edfc2 100644
--- a/tests/ui/issues/issue-61623.stderr
+++ b/tests/ui/issues/issue-61623.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL | fn f3<'a>(x: &'a mut ((), &'a mut ())) {
    |                  +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/issues/issue-62375.stderr b/tests/ui/issues/issue-62375.stderr
index f6d7968c0c4..8750fbcf4cf 100644
--- a/tests/ui/issues/issue-62375.stderr
+++ b/tests/ui/issues/issue-62375.stderr
@@ -21,6 +21,6 @@ help: use parentheses to construct this tuple variant
 LL |     a == A::Value(/* () */);
    |                  ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/issues/issue-64430.stderr b/tests/ui/issues/issue-64430.stderr
index b6b1f3a66c7..1c8e020e9cb 100644
--- a/tests/ui/issues/issue-64430.stderr
+++ b/tests/ui/issues/issue-64430.stderr
@@ -7,6 +7,6 @@ LL | pub struct Foo;
 LL |     Foo.bar()
    |         ^^^ method not found in `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-64559.stderr b/tests/ui/issues/issue-64559.stderr
index 386ac794d7d..0cab3755340 100644
--- a/tests/ui/issues/issue-64559.stderr
+++ b/tests/ui/issues/issue-64559.stderr
@@ -17,6 +17,6 @@ help: consider iterating over a slice of the `Vec<bool>`'s content to avoid movi
 LL |     for _val in &orig {}
    |                 +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/issues/issue-64792-bad-unicode-ctor.stderr b/tests/ui/issues/issue-64792-bad-unicode-ctor.stderr
index 2ec151d24d1..7fc414602d2 100644
--- a/tests/ui/issues/issue-64792-bad-unicode-ctor.stderr
+++ b/tests/ui/issues/issue-64792-bad-unicode-ctor.stderr
@@ -7,6 +7,6 @@ LL |
 LL | const Y: X = X("ö");
    |              ^^^^^^ help: use struct literal syntax instead: `X {}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/issues/issue-65131.stderr b/tests/ui/issues/issue-65131.stderr
index e234e6da552..70e85b584bd 100644
--- a/tests/ui/issues/issue-65131.stderr
+++ b/tests/ui/issues/issue-65131.stderr
@@ -7,6 +7,6 @@ LL |     get_pair(&mut x, &mut x);
    |     |        first mutable borrow occurs here
    |     first borrow later used by call
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/issues/issue-65230.stderr b/tests/ui/issues/issue-65230.stderr
index 7ccab889483..c959658c0ce 100644
--- a/tests/ui/issues/issue-65230.stderr
+++ b/tests/ui/issues/issue-65230.stderr
@@ -13,6 +13,6 @@ LL | impl T1 for &dyn T2 {}
    |             ^
    = note: ...does not necessarily outlive the static lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2015.stderr b/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2015.stderr
index 4af3672ef72..d4266814a7c 100644
--- a/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2015.stderr
+++ b/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2015.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |     await::r#struct(&r#fn {});
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2018.stderr b/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2018.stderr
index 2b96a0fb5e5..fe104bfe445 100644
--- a/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2018.stderr
+++ b/tests/ui/issues/issue-65634-raw-ident-suggestion.edition2018.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |     r#await::r#struct(&r#fn {});
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/issues/issue-6596-2.stderr b/tests/ui/issues/issue-6596-2.stderr
index 4fa73a464fb..e6281eb5427 100644
--- a/tests/ui/issues/issue-6596-2.stderr
+++ b/tests/ui/issues/issue-6596-2.stderr
@@ -9,5 +9,5 @@ LL |     g!(foo);
    |
    = note: this error originates in the macro `g` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-67039-unsound-pin-partialeq.stderr b/tests/ui/issues/issue-67039-unsound-pin-partialeq.stderr
index 6fde44eaf0c..1ea2d48b474 100644
--- a/tests/ui/issues/issue-67039-unsound-pin-partialeq.stderr
+++ b/tests/ui/issues/issue-67039-unsound-pin-partialeq.stderr
@@ -8,6 +8,6 @@ LL |     let _ = Pin::new(Apple) == Rc::pin(Apple);
               found struct `Rc<Apple>`
    = note: required for `Pin<Apple>` to implement `PartialEq<Pin<Rc<Apple>>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/issues/issue-6738.stderr b/tests/ui/issues/issue-6738.stderr
index f97d899c2d3..9c25c0fd9a1 100644
--- a/tests/ui/issues/issue-6738.stderr
+++ b/tests/ui/issues/issue-6738.stderr
@@ -11,6 +11,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::ops::AddAssign> Foo<T> {
    |       +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0368`.
diff --git a/tests/ui/issues/issue-67552.stderr b/tests/ui/issues/issue-67552.stderr
index f93ed67dab2..539bd45dbf1 100644
--- a/tests/ui/issues/issue-67552.stderr
+++ b/tests/ui/issues/issue-67552.stderr
@@ -13,5 +13,5 @@ LL | |     T: Iterator,
    | |________________^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-67552/issue-67552.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-70381.stderr b/tests/ui/issues/issue-70381.stderr
index 96b8e656991..298a1cf9e0d 100644
--- a/tests/ui/issues/issue-70381.stderr
+++ b/tests/ui/issues/issue-70381.stderr
@@ -4,5 +4,5 @@ error: 1 positional argument in format string, but no arguments were given
 LL |   println!("\r¡{}")
    |                ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-7044.stderr b/tests/ui/issues/issue-7044.stderr
index 2ad67ec23be..9d1fb3a10dd 100644
--- a/tests/ui/issues/issue-7044.stderr
+++ b/tests/ui/issues/issue-7044.stderr
@@ -8,6 +8,6 @@ LL | struct X;
    |
    = note: `X` must be defined only once in the value namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/issues/issue-7061.stderr b/tests/ui/issues/issue-7061.stderr
index a209f8a4249..4fca2ff39fe 100644
--- a/tests/ui/issues/issue-7061.stderr
+++ b/tests/ui/issues/issue-7061.stderr
@@ -9,6 +9,6 @@ LL |     fn foo(&'a mut self) -> Box<BarStruct> { self }
    = note:         expected struct `Box<BarStruct>`
            found mutable reference `&'a mut BarStruct`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-7092.stderr b/tests/ui/issues/issue-7092.stderr
index e35379fd1cf..e2e57486746 100644
--- a/tests/ui/issues/issue-7092.stderr
+++ b/tests/ui/issues/issue-7092.stderr
@@ -9,6 +9,6 @@ LL |         Some(field) =>
    = note: expected enum `Whatever`
               found enum `Option<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-71406.stderr b/tests/ui/issues/issue-71406.stderr
index 918163b6094..cd7921f550e 100644
--- a/tests/ui/issues/issue-71406.stderr
+++ b/tests/ui/issues/issue-71406.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: expected type, found function `channel` in `mps
 LL |     let (tx, rx) = mpsc::channel::new(1);
    |                          ^^^^^^^ expected type, found function `channel` in `mpsc`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/issues/issue-71676-2.stderr b/tests/ui/issues/issue-71676-2.stderr
index 80fb4aed1cd..6ed318c8768 100644
--- a/tests/ui/issues/issue-71676-2.stderr
+++ b/tests/ui/issues/issue-71676-2.stderr
@@ -13,6 +13,6 @@ help: consider dereferencing
 LL |     let _: *mut u8 = &mut ***a;
    |                       +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-72076.stderr b/tests/ui/issues/issue-72076.stderr
index b942cf75b06..a08704c9073 100644
--- a/tests/ui/issues/issue-72076.stderr
+++ b/tests/ui/issues/issue-72076.stderr
@@ -9,6 +9,6 @@ LL |     fn f() -> Self::S {}
    = help: consider constraining the associated type `<Self as X>::S` to `()` or calling a method that returns `<Self as X>::S`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-7246.stderr b/tests/ui/issues/issue-7246.stderr
index a9bf2bf763d..1fb6ab14e64 100644
--- a/tests/ui/issues/issue-7246.stderr
+++ b/tests/ui/issues/issue-7246.stderr
@@ -20,5 +20,5 @@ LL |     if *ptr::null() {};
    |
    = note: `#[warn(deref_nullptr)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/issues/issue-72839-error-overflow.stderr b/tests/ui/issues/issue-72839-error-overflow.stderr
index c4b6f90ca69..35be632f579 100644
--- a/tests/ui/issues/issue-72839-error-overflow.stderr
+++ b/tests/ui/issues/issue-72839-error-overflow.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `missing_var` in this scope
 LL |     if missing_var % 8 == 0 {}
    |        ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/issues/issue-73112.stderr b/tests/ui/issues/issue-73112.stderr
index 4b8b979665c..c2c15ca10ce 100644
--- a/tests/ui/issues/issue-73112.stderr
+++ b/tests/ui/issues/issue-73112.stderr
@@ -10,6 +10,6 @@ note: `PageTable` has a `#[repr(align)]` attribute
 LL | pub struct PageTable {
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0588`.
diff --git a/tests/ui/issues/issue-7364.stderr b/tests/ui/issues/issue-7364.stderr
index 7449fe697ae..7371e2105de 100644
--- a/tests/ui/issues/issue-7364.stderr
+++ b/tests/ui/issues/issue-7364.stderr
@@ -11,6 +11,6 @@ note: required because it appears within the type `Box<RefCell<isize>>`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
    = note: shared static variables must have a type that implements `Sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-74236/main.stderr b/tests/ui/issues/issue-74236/main.stderr
index 5cd64e48ab8..a31d29de1d5 100644
--- a/tests/ui/issues/issue-74236/main.stderr
+++ b/tests/ui/issues/issue-74236/main.stderr
@@ -6,6 +6,6 @@ LL |     let () = dep::Renamed;
    |         |
    |         expected `Renamed`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-75283.stderr b/tests/ui/issues/issue-75283.stderr
index da3800affc0..240d9716a55 100644
--- a/tests/ui/issues/issue-75283.stderr
+++ b/tests/ui/issues/issue-75283.stderr
@@ -14,5 +14,5 @@ LL | |     }
    = help: you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-7607-1.stderr b/tests/ui/issues/issue-7607-1.stderr
index c983026995b..db4c8f25dbc 100644
--- a/tests/ui/issues/issue-7607-1.stderr
+++ b/tests/ui/issues/issue-7607-1.stderr
@@ -7,6 +7,6 @@ LL | impl Fo {
    |
    = note: similarly named trait `Fn` defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/issues/issue-76077.stderr b/tests/ui/issues/issue-76077.stderr
index 197ca8d5a7b..4c510e91ada 100644
--- a/tests/ui/issues/issue-76077.stderr
+++ b/tests/ui/issues/issue-76077.stderr
@@ -6,5 +6,5 @@ LL |     foo::Foo {};
    |
    = note: ... and other private field `you_cant_use_this_field` that was not provided
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-77218/issue-77218-2.stderr b/tests/ui/issues/issue-77218/issue-77218-2.stderr
index 58c1c18f9a9..dfed0b6e67e 100644
--- a/tests/ui/issues/issue-77218/issue-77218-2.stderr
+++ b/tests/ui/issues/issue-77218/issue-77218-2.stderr
@@ -11,6 +11,6 @@ help: you might have meant to use pattern destructuring
 LL |     while let Some(0) = value.get(0) {
    |           +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0070`.
diff --git a/tests/ui/issues/issue-77218/issue-77218.stderr b/tests/ui/issues/issue-77218/issue-77218.stderr
index eda635646df..e98e69314d9 100644
--- a/tests/ui/issues/issue-77218/issue-77218.stderr
+++ b/tests/ui/issues/issue-77218/issue-77218.stderr
@@ -11,6 +11,6 @@ help: you might have meant to use pattern destructuring
 LL |     while let Some(0) = value.get(0) {}
    |           +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0070`.
diff --git a/tests/ui/issues/issue-78622.stderr b/tests/ui/issues/issue-78622.stderr
index 70daf8a2f1a..985d6dde9f2 100644
--- a/tests/ui/issues/issue-78622.stderr
+++ b/tests/ui/issues/issue-78622.stderr
@@ -9,6 +9,6 @@ help: if there were a trait named `Example` with associated type `A` implemented
 LL |     <S as Example>::A::<f> {}
    |     ~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/issues/issue-7867.stderr b/tests/ui/issues/issue-7867.stderr
index 4fb1af344cd..1a0cf5da8be 100644
--- a/tests/ui/issues/issue-7867.stderr
+++ b/tests/ui/issues/issue-7867.stderr
@@ -12,6 +12,6 @@ LL |         A::B => (),
    = note: expected tuple `(bool, bool)`
                found enum `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-7950.stderr b/tests/ui/issues/issue-7950.stderr
index b8b0eb310cf..80504c070a3 100644
--- a/tests/ui/issues/issue-7950.stderr
+++ b/tests/ui/issues/issue-7950.stderr
@@ -7,6 +7,6 @@ LL | struct Foo;
 LL |     Foo::bar();
    |          ^^^ function or associated item not found in `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/issues/issue-7970a.stderr b/tests/ui/issues/issue-7970a.stderr
index b04a0eef371..1e6bb92ea57 100644
--- a/tests/ui/issues/issue-7970a.stderr
+++ b/tests/ui/issues/issue-7970a.stderr
@@ -13,5 +13,5 @@ note: while trying to match meta-variable `$fmt:expr`
 LL |     ($fmt:expr) => (print!(concat!($fmt, "\n")));
    |      ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-80607.stderr b/tests/ui/issues/issue-80607.stderr
index 38e46683b08..20494f319dd 100644
--- a/tests/ui/issues/issue-80607.stderr
+++ b/tests/ui/issues/issue-80607.stderr
@@ -12,6 +12,6 @@ help: `Enum::V1` is a tuple variant, use the appropriate syntax
 LL |     Enum::V1(/* fields */)
    |     ~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0559`.
diff --git a/tests/ui/issues/issue-81584.stderr b/tests/ui/issues/issue-81584.stderr
index d57f1b778df..eb97916ad75 100644
--- a/tests/ui/issues/issue-81584.stderr
+++ b/tests/ui/issues/issue-81584.stderr
@@ -9,6 +9,6 @@ LL |             .map(|y| y.iter().map(|x| x + 1))
    |
    = help: use `.collect()` to allocate the iterator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/issues/issue-83048.stderr b/tests/ui/issues/issue-83048.stderr
index dade9e46950..672bf69a732 100644
--- a/tests/ui/issues/issue-83048.stderr
+++ b/tests/ui/issues/issue-83048.stderr
@@ -4,6 +4,6 @@ error[E0268]: `break` outside of a loop or labeled block
 LL |     break;
    |     ^^^^^ cannot `break` outside of a loop or labeled block
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0268`.
diff --git a/tests/ui/issues/issue-87199.stderr b/tests/ui/issues/issue-87199.stderr
index e02cd7fcfa9..d81bc361557 100644
--- a/tests/ui/issues/issue-87199.stderr
+++ b/tests/ui/issues/issue-87199.stderr
@@ -33,6 +33,6 @@ help: consider relaxing the implicit `Sized` restriction
 LL | fn ref_arg<T: ?Send + ?Sized>(_: &T) {}
    |                     ++++++++
 
-error: aborting due to previous error; 3 warnings emitted
+error: aborting due to 1 previous error; 3 warnings emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/issues/issue-8727.stderr b/tests/ui/issues/issue-8727.stderr
index 22332b35723..9af598fe43f 100644
--- a/tests/ui/issues/issue-8727.stderr
+++ b/tests/ui/issues/issue-8727.stderr
@@ -22,5 +22,5 @@ LL | fn generic<T>() {
    | ^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-8727/issue-8727.long-type.txt'
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/issues/issue-87490.stderr b/tests/ui/issues/issue-87490.stderr
index f359dd638ad..5a4ec55833b 100644
--- a/tests/ui/issues/issue-87490.stderr
+++ b/tests/ui/issues/issue-87490.stderr
@@ -9,6 +9,6 @@ LL |     String::new
    = note: expected type `usize`
            found fn item `fn() -> String {String::new}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-8767.stderr b/tests/ui/issues/issue-8767.stderr
index 91d99f393b6..66141628e28 100644
--- a/tests/ui/issues/issue-8767.stderr
+++ b/tests/ui/issues/issue-8767.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `B` in this scope
 LL | impl B {
    |      ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/issues/issue-9575.stderr b/tests/ui/issues/issue-9575.stderr
index e49eac3babf..2f6e2687d24 100644
--- a/tests/ui/issues/issue-9575.stderr
+++ b/tests/ui/issues/issue-9575.stderr
@@ -7,6 +7,6 @@ LL | fn start(argc: isize, argv: *const *const u8, crate_map: *const u8) -> isiz
    = note: expected signature `fn(isize, *const *const u8) -> _`
               found signature `fn(isize, *const *const u8, *const u8) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-9814.stderr b/tests/ui/issues/issue-9814.stderr
index bd9e7df4991..d647edaf37e 100644
--- a/tests/ui/issues/issue-9814.stderr
+++ b/tests/ui/issues/issue-9814.stderr
@@ -4,6 +4,6 @@ error[E0614]: type `Foo` cannot be dereferenced
 LL |     let _ = *Foo::Bar(2);
    |             ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0614`.
diff --git a/tests/ui/issues/issue-98299.stderr b/tests/ui/issues/issue-98299.stderr
index 4fd9f3030fc..e99d8e5cc80 100644
--- a/tests/ui/issues/issue-98299.stderr
+++ b/tests/ui/issues/issue-98299.stderr
@@ -9,6 +9,6 @@ help: consider giving this closure parameter an explicit type, where the value o
 LL |     SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
    |                                        +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/iterators/bound.stderr b/tests/ui/iterators/bound.stderr
index cc7ded498fc..e5ed19f3731 100644
--- a/tests/ui/iterators/bound.stderr
+++ b/tests/ui/iterators/bound.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `S`
 LL | struct S<I: Iterator>(I);
    |             ^^^^^^^^ required by this bound in `S`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/iterators/collect-into-array.stderr b/tests/ui/iterators/collect-into-array.stderr
index e38745cc10e..38e5de803cc 100644
--- a/tests/ui/iterators/collect-into-array.stderr
+++ b/tests/ui/iterators/collect-into-array.stderr
@@ -8,6 +8,6 @@ LL |     let whatever: [u32; 10] = (0..10).collect();
 note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/iterators/float_iterator_hint.stderr b/tests/ui/iterators/float_iterator_hint.stderr
index bae23a1f8ff..c3cb00c3c68 100644
--- a/tests/ui/iterators/float_iterator_hint.stderr
+++ b/tests/ui/iterators/float_iterator_hint.stderr
@@ -8,6 +8,6 @@ LL |     for i in 0.2 {
    = note: if you want to iterate between `start` until a value `end`, use the exclusive range syntax `start..end` or the inclusive range syntax `start..=end`
    = note: required for `{float}` to implement `IntoIterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr b/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
index e728fec2910..f68c596367e 100644
--- a/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
+++ b/tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr
@@ -21,6 +21,6 @@ LL |     let x = Some(()).iter().map(|()| 1).sum::<f32>();
 note: required by a bound in `std::iter::Iterator::sum`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/iterators/vec-on-unimplemented.stderr b/tests/ui/iterators/vec-on-unimplemented.stderr
index a7d9c481a1a..e2a80dbffde 100644
--- a/tests/ui/iterators/vec-on-unimplemented.stderr
+++ b/tests/ui/iterators/vec-on-unimplemented.stderr
@@ -13,6 +13,6 @@ LL |     vec![true, false].map(|v| !v).collect::<Vec<_>>();
            `[bool]: Iterator`
            which is required by `&mut [bool]: Iterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/json/json-short.stderr b/tests/ui/json/json-short.stderr
index 030af0c5ada..a18bceaa6cf 100644
--- a/tests/ui/json/json-short.stderr
+++ b/tests/ui/json/json-short.stderr
@@ -15,5 +15,5 @@ If you don't know the basics of Rust, you can look at the
 [rust-book]: https://doc.rust-lang.org/book/
 "},"level":"error","spans":[{"file_name":"$DIR/json-short.rs","byte_start":62,"byte_end":62,"line_start":1,"line_end":1,"column_start":63,"column_end":63,"is_primary":true,"text":[{"text":"// compile-flags: --json=diagnostic-short --error-format=json","highlight_start":63,"highlight_end":63}],"label":"consider adding a `main` function to `$DIR/json-short.rs`","suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":"$DIR/json-short.rs:1:63: error[E0601]: `main` function not found in crate `json_short`
 "}
-{"$message_type":"diagnostic","message":"aborting due to previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to previous error
+{"$message_type":"diagnostic","message":"aborting due to 1 previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to 1 previous error
 "}
diff --git a/tests/ui/keyword/extern/keyword-extern-as-identifier-expr.stderr b/tests/ui/keyword/extern/keyword-extern-as-identifier-expr.stderr
index 8bb89d2ee21..7cc4a95ac14 100644
--- a/tests/ui/keyword/extern/keyword-extern-as-identifier-expr.stderr
+++ b/tests/ui/keyword/extern/keyword-extern-as-identifier-expr.stderr
@@ -4,5 +4,5 @@ error: expected expression, found keyword `extern`
 LL |     let s = extern::foo::Bar;
    |             ^^^^^^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/keyword/extern/keyword-extern-as-identifier-pat.stderr b/tests/ui/keyword/extern/keyword-extern-as-identifier-pat.stderr
index 9bf416341e8..f9def6fd831 100644
--- a/tests/ui/keyword/extern/keyword-extern-as-identifier-pat.stderr
+++ b/tests/ui/keyword/extern/keyword-extern-as-identifier-pat.stderr
@@ -9,5 +9,5 @@ help: escape `extern` to use it as an identifier
 LL |     let r#extern = 0;
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/keyword/extern/keyword-extern-as-identifier-type.stderr b/tests/ui/keyword/extern/keyword-extern-as-identifier-type.stderr
index 20ecf6bac76..50cac77c1b0 100644
--- a/tests/ui/keyword/extern/keyword-extern-as-identifier-type.stderr
+++ b/tests/ui/keyword/extern/keyword-extern-as-identifier-type.stderr
@@ -4,5 +4,5 @@ error: expected type, found keyword `extern`
 LL | type A = extern::foo::bar;
    |          ^^^^^^ expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/keyword/keyword-false-as-identifier.stderr b/tests/ui/keyword/keyword-false-as-identifier.stderr
index 6dcfa3a4811..b8f0901bc30 100644
--- a/tests/ui/keyword/keyword-false-as-identifier.stderr
+++ b/tests/ui/keyword/keyword-false-as-identifier.stderr
@@ -6,6 +6,6 @@ LL |     let false = 22;
    |         |
    |         expected integer, found `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/keyword/keyword-self-as-identifier.stderr b/tests/ui/keyword/keyword-self-as-identifier.stderr
index 060e7c3eafc..098ef8d82a0 100644
--- a/tests/ui/keyword/keyword-self-as-identifier.stderr
+++ b/tests/ui/keyword/keyword-self-as-identifier.stderr
@@ -4,6 +4,6 @@ error[E0531]: cannot find unit struct, unit variant or constant `Self` in this s
 LL |     let Self = 22;
    |         ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0531`.
diff --git a/tests/ui/keyword/keyword-super-as-identifier.stderr b/tests/ui/keyword/keyword-super-as-identifier.stderr
index 1f64f3b73d6..bfb27c143ff 100644
--- a/tests/ui/keyword/keyword-super-as-identifier.stderr
+++ b/tests/ui/keyword/keyword-super-as-identifier.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: there are too many leading `super` keywords
 LL |     let super = 22;
    |         ^^^^^ there are too many leading `super` keywords
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/keyword/keyword-super.stderr b/tests/ui/keyword/keyword-super.stderr
index 0e0d67cb97b..bf595442c3b 100644
--- a/tests/ui/keyword/keyword-super.stderr
+++ b/tests/ui/keyword/keyword-super.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: there are too many leading `super` keywords
 LL |     let super: isize;
    |         ^^^^^ there are too many leading `super` keywords
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/keyword/keyword-true-as-identifier.stderr b/tests/ui/keyword/keyword-true-as-identifier.stderr
index 86f6e00064f..0f7a8a7e7ea 100644
--- a/tests/ui/keyword/keyword-true-as-identifier.stderr
+++ b/tests/ui/keyword/keyword-true-as-identifier.stderr
@@ -6,6 +6,6 @@ LL |     let true = 22;
    |         |
    |         expected integer, found `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/kindck/kindck-impl-type-params-2.stderr b/tests/ui/kindck/kindck-impl-type-params-2.stderr
index 1d26ae51f44..a51232090ad 100644
--- a/tests/ui/kindck/kindck-impl-type-params-2.stderr
+++ b/tests/ui/kindck/kindck-impl-type-params-2.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `take_param`
 LL | fn take_param<T:Foo>(foo: &T) { }
    |                 ^^^ required by this bound in `take_param`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-nonsendable-1.stderr b/tests/ui/kindck/kindck-nonsendable-1.stderr
index 077004ae761..8bb784d1d49 100644
--- a/tests/ui/kindck/kindck-nonsendable-1.stderr
+++ b/tests/ui/kindck/kindck-nonsendable-1.stderr
@@ -20,6 +20,6 @@ note: required by a bound in `bar`
 LL | fn bar<F:FnOnce() + Send>(_: F) { }
    |                     ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/kindck/kindck-send-owned.stderr b/tests/ui/kindck/kindck-send-owned.stderr
index dc1bb6206af..860a9391bbb 100644
--- a/tests/ui/kindck/kindck-send-owned.stderr
+++ b/tests/ui/kindck/kindck-send-owned.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `assert_send`
 LL | fn assert_send<T:Send>() { }
    |                  ^^^^ required by this bound in `assert_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/lang-items/bad-add-impl.stderr b/tests/ui/lang-items/bad-add-impl.stderr
index 3143729f99b..c5ad9ff2a08 100644
--- a/tests/ui/lang-items/bad-add-impl.stderr
+++ b/tests/ui/lang-items/bad-add-impl.stderr
@@ -6,6 +6,6 @@ LL |     1u32 + 1u32;
    |     |
    |     u32
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/lang-items/issue-19660.stderr b/tests/ui/lang-items/issue-19660.stderr
index f5d903f38eb..e5a8a143d03 100644
--- a/tests/ui/lang-items/issue-19660.stderr
+++ b/tests/ui/lang-items/issue-19660.stderr
@@ -1,4 +1,4 @@
 error: requires `copy` lang_item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lang-items/issue-86238.stderr b/tests/ui/lang-items/issue-86238.stderr
index c6e811a94fe..b492904bcc7 100644
--- a/tests/ui/lang-items/issue-86238.stderr
+++ b/tests/ui/lang-items/issue-86238.stderr
@@ -6,5 +6,5 @@ LL |     one()
    |
    = help: make sure the `fn`/`fn_mut`/`fn_once` lang items are defined and have correctly defined `call`/`call_mut`/`call_once` methods
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lang-items/lang-item-missing.stderr b/tests/ui/lang-items/lang-item-missing.stderr
index f7516c7d377..08e679a7c55 100644
--- a/tests/ui/lang-items/lang-item-missing.stderr
+++ b/tests/ui/lang-items/lang-item-missing.stderr
@@ -1,4 +1,4 @@
 error: requires `sized` lang_item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lang-items/missing-clone-for-suggestion.stderr b/tests/ui/lang-items/missing-clone-for-suggestion.stderr
index 35783a1be78..0187f965b5c 100644
--- a/tests/ui/lang-items/missing-clone-for-suggestion.stderr
+++ b/tests/ui/lang-items/missing-clone-for-suggestion.stderr
@@ -16,6 +16,6 @@ LL | fn g<T>(x: T) {}
    |    |
    |    in this function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/lang-items/required-lang-item.stderr b/tests/ui/lang-items/required-lang-item.stderr
index 83764a91ac7..bb53d336bb2 100644
--- a/tests/ui/lang-items/required-lang-item.stderr
+++ b/tests/ui/lang-items/required-lang-item.stderr
@@ -1,4 +1,4 @@
 error: requires `start` lang_item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lang-items/start_lang_item_args.argc.stderr b/tests/ui/lang-items/start_lang_item_args.argc.stderr
index 66d4397a293..cd7361255eb 100644
--- a/tests/ui/lang-items/start_lang_item_args.argc.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.argc.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: i8, _argv: *const *const u8, _sigpipe:
    = note: expected signature `fn(fn() -> _, isize, _, _) -> _`
               found signature `fn(fn() -> _, i8, _, _) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.argv.stderr b/tests/ui/lang-items/start_lang_item_args.argv.stderr
index 53d776cd846..1a5905ab8e6 100644
--- a/tests/ui/lang-items/start_lang_item_args.argv.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.argv.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: u8, _sigpipe: u8) -> isi
    = note: expected signature `fn(fn() -> _, _, *const *const u8, _) -> _`
               found signature `fn(fn() -> _, _, u8, _) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.argv_inner_ptr.stderr b/tests/ui/lang-items/start_lang_item_args.argv_inner_ptr.stderr
index 7d002e090b5..c61ace3cd62 100644
--- a/tests/ui/lang-items/start_lang_item_args.argv_inner_ptr.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.argv_inner_ptr.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const usize, _si
    = note: expected signature `fn(fn() -> _, _, *const *const u8, _) -> _`
               found signature `fn(fn() -> _, _, *const *const usize, _) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.main_args.stderr b/tests/ui/lang-items/start_lang_item_args.main_args.stderr
index 91994b9d742..ef943d6b3db 100644
--- a/tests/ui/lang-items/start_lang_item_args.main_args.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.main_args.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn(i32) -> T, _argc: isize, _argv: *const *const u8, _si
    = note: expected signature `fn(fn() -> _, _, _, _) -> _`
               found signature `fn(fn(i32) -> _, _, _, _) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.main_ret.stderr b/tests/ui/lang-items/start_lang_item_args.main_ret.stderr
index 25570f96053..00395a05d33 100644
--- a/tests/ui/lang-items/start_lang_item_args.main_ret.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.main_ret.stderr
@@ -9,6 +9,6 @@ LL | fn start<T>(_main: fn() -> u16, _argc: isize, _argv: *const *const u8, _sig
    = note: expected signature `fn(fn() -> T, _, _, _) -> _`
               found signature `fn(fn() -> u16, _, _, _) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.main_ty.stderr b/tests/ui/lang-items/start_lang_item_args.main_ty.stderr
index 87940d05e78..193f25bab05 100644
--- a/tests/ui/lang-items/start_lang_item_args.main_ty.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.main_ty.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: u64, _argc: isize, _argv: *const *const u8, _sigpipe: u8
    = note: expected signature `fn(fn() -> T, _, _, _) -> _`
               found signature `fn(u64, _, _, _) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.missing_all_args.stderr b/tests/ui/lang-items/start_lang_item_args.missing_all_args.stderr
index 5363871e202..56b787d2ae3 100644
--- a/tests/ui/lang-items/start_lang_item_args.missing_all_args.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.missing_all_args.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>() -> isize {
    = note: expected signature `fn(fn() -> T, isize, *const *const u8, u8) -> _`
               found signature `fn() -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.missing_ret.stderr b/tests/ui/lang-items/start_lang_item_args.missing_ret.stderr
index 14bfcc3d04d..aa1b1b73bae 100644
--- a/tests/ui/lang-items/start_lang_item_args.missing_ret.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.missing_ret.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8, _sigpi
    = note: expected signature `fn(fn() -> _, _, _, _) -> isize`
               found signature `fn(fn() -> _, _, _, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.missing_sigpipe_arg.stderr b/tests/ui/lang-items/start_lang_item_args.missing_sigpipe_arg.stderr
index f873f7614bd..98814dcd24a 100644
--- a/tests/ui/lang-items/start_lang_item_args.missing_sigpipe_arg.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.missing_sigpipe_arg.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8) -> isi
    = note: expected signature `fn(fn() -> T, isize, *const *const u8, u8) -> _`
               found signature `fn(fn() -> T, isize, *const *const u8) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.sigpipe.stderr b/tests/ui/lang-items/start_lang_item_args.sigpipe.stderr
index 280d423bd7e..e0a8496dba9 100644
--- a/tests/ui/lang-items/start_lang_item_args.sigpipe.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.sigpipe.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8, _sigpi
    = note: expected signature `fn(fn() -> _, _, _, u8) -> _`
               found signature `fn(fn() -> _, _, _, i64) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.start_ret.stderr b/tests/ui/lang-items/start_lang_item_args.start_ret.stderr
index 4e4f8a5cdb3..4437b0fdcfb 100644
--- a/tests/ui/lang-items/start_lang_item_args.start_ret.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.start_ret.stderr
@@ -7,6 +7,6 @@ LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8, _sigpi
    = note: expected signature `fn(fn() -> _, _, _, _) -> isize`
               found signature `fn(fn() -> _, _, _, _) -> u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_args.too_many_args.stderr b/tests/ui/lang-items/start_lang_item_args.too_many_args.stderr
index 085d4b1f238..8570d96fc62 100644
--- a/tests/ui/lang-items/start_lang_item_args.too_many_args.stderr
+++ b/tests/ui/lang-items/start_lang_item_args.too_many_args.stderr
@@ -13,6 +13,6 @@ LL | | ) -> isize {
    = note: expected signature `fn(fn() -> T, isize, *const *const u8, u8) -> _`
               found signature `fn(fn() -> T, isize, *const *const u8, u8, ()) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lang-items/start_lang_item_with_target_feature.stderr b/tests/ui/lang-items/start_lang_item_with_target_feature.stderr
index ff55a1365e4..bb0583dfde0 100644
--- a/tests/ui/lang-items/start_lang_item_with_target_feature.stderr
+++ b/tests/ui/lang-items/start_lang_item_with_target_feature.stderr
@@ -7,5 +7,5 @@ LL |
 LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8, _sigpipe: u8) -> isize {
    | ------------------------------------------------------------------------------------------- `start` language item function is not allowed to have `#[target_feature]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/late-bound-lifetimes/issue-80618.stderr b/tests/ui/late-bound-lifetimes/issue-80618.stderr
index cf7423fc16f..28ea61f38a3 100644
--- a/tests/ui/late-bound-lifetimes/issue-80618.stderr
+++ b/tests/ui/late-bound-lifetimes/issue-80618.stderr
@@ -10,6 +10,6 @@ note: the late bound lifetime parameter is introduced here
 LL | fn foo<'a>(x: &'a str) -> &'a str {
    |        ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0794`.
diff --git a/tests/ui/late-bound-lifetimes/mismatched_arg_count.stderr b/tests/ui/late-bound-lifetimes/mismatched_arg_count.stderr
index de58a014ee8..1b8f1c3fd6f 100644
--- a/tests/ui/late-bound-lifetimes/mismatched_arg_count.stderr
+++ b/tests/ui/late-bound-lifetimes/mismatched_arg_count.stderr
@@ -12,6 +12,6 @@ note: type alias defined here, with 1 lifetime parameter: `'a`
 LL | type Alias<'a, T> = <T as Trait<'a>>::Assoc;
    |      ^^^^^ --
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/layout/cannot-transmute-unnormalizable-type.stderr b/tests/ui/layout/cannot-transmute-unnormalizable-type.stderr
index ee2c5ab7e39..d17564a1eca 100644
--- a/tests/ui/layout/cannot-transmute-unnormalizable-type.stderr
+++ b/tests/ui/layout/cannot-transmute-unnormalizable-type.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Missing` in this scope
 LL |     Missing: Trait,
    |     ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/layout/malformed-unsized-type-in-union.stderr b/tests/ui/layout/malformed-unsized-type-in-union.stderr
index cbb8d6af38a..ad4f0cda19e 100644
--- a/tests/ui/layout/malformed-unsized-type-in-union.stderr
+++ b/tests/ui/layout/malformed-unsized-type-in-union.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Missing` in this scope
 LL | union W { s: dyn Iterator<Item = Missing> }
    |                                  ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/layout/too-big-with-padding.stderr b/tests/ui/layout/too-big-with-padding.stderr
index 5cc854adce0..71309788dac 100644
--- a/tests/ui/layout/too-big-with-padding.stderr
+++ b/tests/ui/layout/too-big-with-padding.stderr
@@ -4,5 +4,5 @@ error: values of the type `Example` are too big for the current architecture
 LL | pub fn lib(_x: Example) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/layout/transmute-to-tail-with-err.stderr b/tests/ui/layout/transmute-to-tail-with-err.stderr
index 97ab59c398a..433c6b38d0b 100644
--- a/tests/ui/layout/transmute-to-tail-with-err.stderr
+++ b/tests/ui/layout/transmute-to-tail-with-err.stderr
@@ -9,6 +9,6 @@ help: you might be missing a type parameter
 LL | struct Bar<T>(Box<dyn Trait<T>>);
    |           +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/lazy-type-alias-impl-trait/branches.stderr b/tests/ui/lazy-type-alias-impl-trait/branches.stderr
index 0b206f31e7b..9e937622775 100644
--- a/tests/ui/lazy-type-alias-impl-trait/branches.stderr
+++ b/tests/ui/lazy-type-alias-impl-trait/branches.stderr
@@ -8,6 +8,6 @@ LL |         std::iter::empty().collect()
 note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_eager.stderr b/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_eager.stderr
index 3b216ac1581..fdc5bae1537 100644
--- a/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_eager.stderr
+++ b/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_eager.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `lazy::Alias`
 LL | pub type Alias<T: Copy> = Option<T>;
    |                   ^^^^ required by this bound in `Alias`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_lazy.stderr b/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_lazy.stderr
index 3b216ac1581..fdc5bae1537 100644
--- a/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_lazy.stderr
+++ b/tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_lazy.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `lazy::Alias`
 LL | pub type Alias<T: Copy> = Option<T>;
    |                   ^^^^ required by this bound in `Alias`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/lazy-type-alias/leading-where-clause.stderr b/tests/ui/lazy-type-alias/leading-where-clause.stderr
index 8ddf0ce6c65..6b0613787e8 100644
--- a/tests/ui/lazy-type-alias/leading-where-clause.stderr
+++ b/tests/ui/lazy-type-alias/leading-where-clause.stderr
@@ -12,5 +12,5 @@ LL +
 LL ~ = T where String: From<T>;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lazy-type-alias/trailing-where-clause.stderr b/tests/ui/lazy-type-alias/trailing-where-clause.stderr
index 193f80b23d3..baf4215bbf7 100644
--- a/tests/ui/lazy-type-alias/trailing-where-clause.stderr
+++ b/tests/ui/lazy-type-alias/trailing-where-clause.stderr
@@ -20,6 +20,6 @@ LL | where
 LL |     String: From<T>;
    |             ^^^^^^^ required by this bound in `Alias`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr b/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
index d022f825140..bd8095224a7 100644
--- a/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
+++ b/tests/ui/lazy-type-alias/unsatisfied-bounds-type-alias-body.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | type Alias<T: std::ops::Mul> = <T as std::ops::Mul>::Output;
    |             +++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/let-else/accidental-if.stderr b/tests/ui/let-else/accidental-if.stderr
index 57e52591730..12948e956ca 100644
--- a/tests/ui/let-else/accidental-if.stderr
+++ b/tests/ui/let-else/accidental-if.stderr
@@ -15,5 +15,5 @@ LL -     if let Some(y) = x else {
 LL +     let Some(y) = x else {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/let-else/issue-94176.stderr b/tests/ui/let-else/issue-94176.stderr
index 6a015aced6f..1ff5000e7a3 100644
--- a/tests/ui/let-else/issue-94176.stderr
+++ b/tests/ui/let-else/issue-94176.stderr
@@ -14,6 +14,6 @@ LL ~     println!("Foo");
 LL +     a
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/let-else/let-else-allow-unused.stderr b/tests/ui/let-else/let-else-allow-unused.stderr
index 05b8a9169fb..2cad1be8c46 100644
--- a/tests/ui/let-else/let-else-allow-unused.stderr
+++ b/tests/ui/let-else/let-else-allow-unused.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #[deny(unused_variables)]
    |        ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/let-else/let-else-binding-explicit-mut-borrow.stderr b/tests/ui/let-else/let-else-binding-explicit-mut-borrow.stderr
index 023fab8fe4a..e4d6534c515 100644
--- a/tests/ui/let-else/let-else-binding-explicit-mut-borrow.stderr
+++ b/tests/ui/let-else/let-else-binding-explicit-mut-borrow.stderr
@@ -4,6 +4,6 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     let Some(n): &mut Option<i32> = &mut &Some(5i32) else {
    |                                     ^^^^^^^^^^^^^^^^ cannot borrow as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/let-else/let-else-binding-immutable.stderr b/tests/ui/let-else/let-else-binding-immutable.stderr
index dd1365a9ef0..0f854493b7e 100644
--- a/tests/ui/let-else/let-else-binding-immutable.stderr
+++ b/tests/ui/let-else/let-else-binding-immutable.stderr
@@ -4,6 +4,6 @@ error[E0594]: cannot assign to `*x`, which is behind a `&` reference
 LL |     *x += 1;
    |     ^^^^^^^ `x` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/let-else/let-else-if.stderr b/tests/ui/let-else/let-else-if.stderr
index c63fd61c5de..c8058ec6692 100644
--- a/tests/ui/let-else/let-else-if.stderr
+++ b/tests/ui/let-else/let-else-if.stderr
@@ -13,5 +13,5 @@ LL |         return;
 LL ~     } };
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/let-else/let-else-no-double-error.stderr b/tests/ui/let-else/let-else-no-double-error.stderr
index 941e588b176..05668a23138 100644
--- a/tests/ui/let-else/let-else-no-double-error.stderr
+++ b/tests/ui/let-else/let-else-no-double-error.stderr
@@ -4,6 +4,6 @@ error[E0599]: no associated item named `XXX` found for type `u32` in the current
 LL |     let u32::XXX = foo else { return };
    |              ^^^ associated item not found in `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/let-else/let-else-scope.stderr b/tests/ui/let-else/let-else-scope.stderr
index 3b4f0982940..335ee3dfb1e 100644
--- a/tests/ui/let-else/let-else-scope.stderr
+++ b/tests/ui/let-else/let-else-scope.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `x` in this scope
 LL |         panic!("{}", x);
    |                      ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/let-else/let-else-slicing-error.stderr b/tests/ui/let-else/let-else-slicing-error.stderr
index 064025e0345..73c357dd5d4 100644
--- a/tests/ui/let-else/let-else-slicing-error.stderr
+++ b/tests/ui/let-else/let-else-slicing-error.stderr
@@ -6,6 +6,6 @@ LL |     let [x, y] = nums else {
    |         |
    |         pattern cannot match with input type `Vec<{integer}>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0529`.
diff --git a/tests/ui/let-else/let-else-then-diverge.stderr b/tests/ui/let-else/let-else-then-diverge.stderr
index 470a11d4769..eda0025afa5 100644
--- a/tests/ui/let-else/let-else-then-diverge.stderr
+++ b/tests/ui/let-else/let-else-then-diverge.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lexer/lex-bad-char-literals-2.stderr b/tests/ui/lexer/lex-bad-char-literals-2.stderr
index c2b19a7ad5f..1518a37ab53 100644
--- a/tests/ui/lexer/lex-bad-char-literals-2.stderr
+++ b/tests/ui/lexer/lex-bad-char-literals-2.stderr
@@ -9,5 +9,5 @@ help: if you meant to write a `str` literal, use double quotes
 LL |     "nope"
    |     ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lexer/lex-bad-char-literals-4.stderr b/tests/ui/lexer/lex-bad-char-literals-4.stderr
index fec4421c48a..1a1dd85e606 100644
--- a/tests/ui/lexer/lex-bad-char-literals-4.stderr
+++ b/tests/ui/lexer/lex-bad-char-literals-4.stderr
@@ -4,6 +4,6 @@ error[E0762]: unterminated character literal
 LL |     '●
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0762`.
diff --git a/tests/ui/lexer/lex-bad-token.stderr b/tests/ui/lexer/lex-bad-token.stderr
index 43c43721b19..6ce309ca205 100644
--- a/tests/ui/lexer/lex-bad-token.stderr
+++ b/tests/ui/lexer/lex-bad-token.stderr
@@ -4,5 +4,5 @@ error: unknown start of token: \u{25cf}
 LL | ●
    | ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lexer/lex-stray-backslash.stderr b/tests/ui/lexer/lex-stray-backslash.stderr
index 06dc0f2b537..6173a4b1d51 100644
--- a/tests/ui/lexer/lex-stray-backslash.stderr
+++ b/tests/ui/lexer/lex-stray-backslash.stderr
@@ -4,5 +4,5 @@ error: unknown start of token: \
 LL | \
    | ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lexer/unterminated-comment.stderr b/tests/ui/lexer/unterminated-comment.stderr
index c513fafeeb3..ea65bffd103 100644
--- a/tests/ui/lexer/unterminated-comment.stderr
+++ b/tests/ui/lexer/unterminated-comment.stderr
@@ -4,6 +4,6 @@ error[E0758]: unterminated block comment
 LL | /*
    | ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0758`.
diff --git a/tests/ui/lexer/unterminated-nested-comment.stderr b/tests/ui/lexer/unterminated-nested-comment.stderr
index 3653e76c9cb..9117b689c94 100644
--- a/tests/ui/lexer/unterminated-nested-comment.stderr
+++ b/tests/ui/lexer/unterminated-nested-comment.stderr
@@ -16,6 +16,6 @@ LL | | */
    |   |
    |   ...and last nested comment terminates here.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0758`.
diff --git a/tests/ui/lifetimes/borrowck-let-suggestion.stderr b/tests/ui/lifetimes/borrowck-let-suggestion.stderr
index 62119664764..cca7f52957e 100644
--- a/tests/ui/lifetimes/borrowck-let-suggestion.stderr
+++ b/tests/ui/lifetimes/borrowck-let-suggestion.stderr
@@ -20,6 +20,6 @@ LL ~     let binding = vec![1];
 LL ~     let mut x = binding.iter();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/lifetimes/conflicting-bounds.stderr b/tests/ui/lifetimes/conflicting-bounds.stderr
index 42aa393667d..cd66eb5e3fe 100644
--- a/tests/ui/lifetimes/conflicting-bounds.stderr
+++ b/tests/ui/lifetimes/conflicting-bounds.stderr
@@ -9,6 +9,6 @@ LL | pub trait Gen<'source> {
 LL |         Self: for<'s> Gen<'s, Output = T>;
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/lifetimes/copy_modulo_regions.stderr b/tests/ui/lifetimes/copy_modulo_regions.stderr
index 87dbb64abd1..310ddb21647 100644
--- a/tests/ui/lifetimes/copy_modulo_regions.stderr
+++ b/tests/ui/lifetimes/copy_modulo_regions.stderr
@@ -10,5 +10,5 @@ LL |     [mk_foo::<'a>(); 100]
    = note: the struct `Foo<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/issue-103582-hint-for-missing-lifetime-bound-on-trait-object-using-type-alias.stderr b/tests/ui/lifetimes/issue-103582-hint-for-missing-lifetime-bound-on-trait-object-using-type-alias.stderr
index 808d8bb9058..24bb9e2ef7d 100644
--- a/tests/ui/lifetimes/issue-103582-hint-for-missing-lifetime-bound-on-trait-object-using-type-alias.stderr
+++ b/tests/ui/lifetimes/issue-103582-hint-for-missing-lifetime-bound-on-trait-object-using-type-alias.stderr
@@ -11,5 +11,5 @@ help: to declare that the trait object captures data from argument `self`, you c
 LL | type BoxedGreeter<'a> = (Box<dyn Greeter0 + 'a>, Box<dyn Greeter1 + 'a>);
    |                  ++++                     ++++                    ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/issue-107492-default-value-for-lifetime.stderr b/tests/ui/lifetimes/issue-107492-default-value-for-lifetime.stderr
index c235c31809f..9bc2263ab3d 100644
--- a/tests/ui/lifetimes/issue-107492-default-value-for-lifetime.stderr
+++ b/tests/ui/lifetimes/issue-107492-default-value-for-lifetime.stderr
@@ -4,5 +4,5 @@ error: unexpected default lifetime parameter
 LL | pub struct DefaultLifetime<'a, 'b = 'static> {
    |                                   ^^^^^^^^^ lifetime parameters cannot have default values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/issue-17728.stderr b/tests/ui/lifetimes/issue-17728.stderr
index 535073d6ebb..fb1c7cf7ad3 100644
--- a/tests/ui/lifetimes/issue-17728.stderr
+++ b/tests/ui/lifetimes/issue-17728.stderr
@@ -16,6 +16,6 @@ LL | |     }
    = note: expected enum `RoomDirection`
               found enum `Option<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lifetimes/issue-34979.stderr b/tests/ui/lifetimes/issue-34979.stderr
index 3d4208031cd..0877f1548a8 100644
--- a/tests/ui/lifetimes/issue-34979.stderr
+++ b/tests/ui/lifetimes/issue-34979.stderr
@@ -15,6 +15,6 @@ LL |     &'a (): Foo,
 LL |     &'static (): Foo;
    |                  ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/lifetimes/issue-83753-invalid-associated-type-supertrait-hrtb.stderr b/tests/ui/lifetimes/issue-83753-invalid-associated-type-supertrait-hrtb.stderr
index f7bdee6336e..d99ea6a0c30 100644
--- a/tests/ui/lifetimes/issue-83753-invalid-associated-type-supertrait-hrtb.stderr
+++ b/tests/ui/lifetimes/issue-83753-invalid-associated-type-supertrait-hrtb.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     fn bar(foo: Foo<Target = usize>) {}
    |                     ^^^^^^^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/lifetimes/issue-91763.stderr b/tests/ui/lifetimes/issue-91763.stderr
index 6ccf008c003..f7293ed809c 100644
--- a/tests/ui/lifetimes/issue-91763.stderr
+++ b/tests/ui/lifetimes/issue-91763.stderr
@@ -14,5 +14,5 @@ help: indicate the anonymous lifetime
 LL | fn f() -> Ptr<Thing><'_>;
    |                     ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-elision-return-type-trait.stderr b/tests/ui/lifetimes/lifetime-elision-return-type-trait.stderr
index 421ab3fcf4e..1664466df3c 100644
--- a/tests/ui/lifetimes/lifetime-elision-return-type-trait.stderr
+++ b/tests/ui/lifetimes/lifetime-elision-return-type-trait.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Future {
    | ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/lifetimes/lifetime-errors/42701_one_named_and_one_anonymous.stderr b/tests/ui/lifetimes/lifetime-errors/42701_one_named_and_one_anonymous.stderr
index 63d00875dd3..af22078aff5 100644
--- a/tests/ui/lifetimes/lifetime-errors/42701_one_named_and_one_anonymous.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/42701_one_named_and_one_anonymous.stderr
@@ -7,6 +7,6 @@ LL | fn foo2<'a>(a: &'a Foo, x: &i32) -> &'a i32 {
 LL |         &*x
    |         ^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-early-bound-in-struct.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-early-bound-in-struct.stderr
index 64aa8361cd5..e202c31214d 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-early-bound-in-struct.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-early-bound-in-struct.stderr
@@ -7,6 +7,6 @@ LL |     fn bar(&self, other: Foo) -> Foo<'a> {
 LL |                     other
    |                     ^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-2.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-2.stderr
index b40481ecdc4..5518ded0106 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-2.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-2.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>(x: &i32, y: &'a i32) -> &'a i32 {
 LL |     if x > y { x } else { y }
    |                ^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-3.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-3.stderr
index 194fd95891e..c689fa9884a 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-3.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-3.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>((x, y): (&'a i32, &i32)) -> &'a i32 {
 LL |     if x > y { x } else { y }
    |                           ^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-2.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-2.stderr
index 64f4bd0fc70..3da50cfbb1d 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-2.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-2.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>(x: &i32, y: &'a i32) -> &'a i32 {
 LL |    if x > y { x } else { y }
    |               ^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-3.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-3.stderr
index 961f9de6614..6dda9e61a79 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-3.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-3.stderr
@@ -7,6 +7,6 @@ LL |
 LL |     if true { &self.field } else { x }
    |                                    ^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl.stderr
index 5bb76381332..5827b2fe695 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl.stderr
@@ -9,5 +9,5 @@ LL |
 LL |         if x > y { x } else { y }
    |                    ^ associated function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else.stderr
index 29a70695710..1df0776a51b 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32 {
 LL |     if x > y { x } else { y }
    |                           ^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr
index 6fd7f67d15e..da454b8fd86 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr
@@ -9,5 +9,5 @@ LL |
 LL |     x
    |     ^ method was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-self-is-anon.stderr b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-self-is-anon.stderr
index 2687266e098..a1dfff883a0 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-self-is-anon.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-self-is-anon.stderr
@@ -9,5 +9,5 @@ LL |
 LL |         if true { x } else { self }
    |                              ^^^^ method was supposed to return data with lifetime `'a` but it is returning data with lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex1b-return-no-names-if-else.stderr b/tests/ui/lifetimes/lifetime-errors/ex1b-return-no-names-if-else.stderr
index bcc3e9510ac..62b0a8a04bf 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex1b-return-no-names-if-else.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex1b-return-no-names-if-else.stderr
@@ -10,6 +10,6 @@ help: consider introducing a named lifetime parameter
 LL | fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
    |       ++++     ++          ++          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-2.stderr b/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-2.stderr
index 90d4754ebab..25a2f4b96f4 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-2.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-2.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>(x: Ref<i32>, y: &mut Vec<Ref<'a, i32>>) {
 LL |     y.push(x);
    |     ^^^^^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.stderr b/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.stderr
index a03e16b3b79..e2725977d83 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.stderr
@@ -7,6 +7,6 @@ LL | fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T)
 LL |     x.push(y);
    |     ^^^^^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name.stderr b/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name.stderr
index 487b34e3d18..1025581d5ac 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name.stderr
@@ -6,6 +6,6 @@ LL | fn foo<'a>(x: &mut Vec<Ref<'a, i32>>, y: Ref<i32>) {
 LL |     x.push(y);
    |     ^^^^^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2b-push-no-existing-names.stderr b/tests/ui/lifetimes/lifetime-errors/ex2b-push-no-existing-names.stderr
index 1622ce42290..df1d03d5170 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2b-push-no-existing-names.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2b-push-no-existing-names.stderr
@@ -8,5 +8,5 @@ LL | fn foo(x: &mut Vec<Ref<i32>>, y: Ref<i32>) {
 LL |     x.push(y);
    |     ^^^^^^^^^ argument requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2c-push-inference-variable.stderr b/tests/ui/lifetimes/lifetime-errors/ex2c-push-inference-variable.stderr
index 99fab4631a2..cace80272f5 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2c-push-inference-variable.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2c-push-inference-variable.stderr
@@ -11,5 +11,5 @@ LL |     x.push(z);
    |
    = help: consider adding the following bound: `'c: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2d-push-inference-variable-2.stderr b/tests/ui/lifetimes/lifetime-errors/ex2d-push-inference-variable-2.stderr
index 52c5752f6ea..4a981e4de60 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2d-push-inference-variable-2.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2d-push-inference-variable-2.stderr
@@ -11,5 +11,5 @@ LL |     a.push(b);
    |
    = help: consider adding the following bound: `'c: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex2e-push-inference-variable-3.stderr b/tests/ui/lifetimes/lifetime-errors/ex2e-push-inference-variable-3.stderr
index e90c81ee3e1..2bd047113bc 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex2e-push-inference-variable-3.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex2e-push-inference-variable-3.stderr
@@ -11,5 +11,5 @@ LL |     Vec::push(a, b);
    |
    = help: consider adding the following bound: `'c: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-2.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-2.stderr
index 5a23f1e0e9d..30083b5ef54 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-2.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-2.stderr
@@ -13,5 +13,5 @@ help: consider introducing a named lifetime parameter
 LL | fn foo<'a>(&mut (ref mut v, w): &mut (&'a u8, &u8), x: &'a u8) {
    |       ++++                             ++               ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-2.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-2.stderr
index 4c0ffe5c090..4f1cb1e7972 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-2.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-2.stderr
@@ -8,5 +8,5 @@ LL | fn foo(mut x: Ref, y: Ref) {
 LL |     x.b = y.b;
    |     ^^^^^^^^^ assignment requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-3.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-3.stderr
index 97c665347f6..3a1947973b5 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-3.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-3.stderr
@@ -9,5 +9,5 @@ LL | fn foo(mut x: Ref) {
 LL |     x.a = x.b;
    |     ^^^^^^^^^ assignment requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-earlybound-regions.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-earlybound-regions.stderr
index b3d0bc2b882..352619c0ffc 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-earlybound-regions.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-earlybound-regions.stderr
@@ -11,5 +11,5 @@ LL |     x.push(y);
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-latebound-regions.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-latebound-regions.stderr
index fbe98a4263e..16cf009ee48 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-latebound-regions.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-latebound-regions.stderr
@@ -10,5 +10,5 @@ LL |     x.push(y);
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs.stderr
index 9630729d0ee..c778f77366a 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs.stderr
@@ -8,5 +8,5 @@ LL | fn foo(mut x: Vec<Ref>, y: Ref) {
 LL |     x.push(y);
    |     ^^^^^^^^^ argument requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-latebound-regions.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-latebound-regions.stderr
index 1e24032fc1c..080eb43cecb 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-latebound-regions.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-latebound-regions.stderr
@@ -10,5 +10,5 @@ LL |     x.push(y);
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-3.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-3.stderr
index 79e7e8e157d..60ca4168455 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-3.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-3.stderr
@@ -8,5 +8,5 @@ LL | fn foo(mut y: Ref, x: &u32) {
 LL |     y.b = x;
    |     ^^^^^^^ assignment requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-4.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-4.stderr
index 53615fd1aba..98e490c3827 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-4.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-4.stderr
@@ -8,5 +8,5 @@ LL | fn foo(mut y: Ref, x: &u32) {
 LL |     y.b = x;
    |     ^^^^^^^ assignment requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct.stderr
index 6ff44116737..ea1cc1f18a4 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct.stderr
@@ -8,5 +8,5 @@ LL | fn foo(mut x: Ref, y: &u32) {
 LL |     x.b = y;
    |     ^^^^^^^ assignment requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.stderr
index 9ff5e42d732..e934ce7c040 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.stderr
@@ -13,5 +13,5 @@ help: consider introducing a named lifetime parameter and update trait if needed
 LL |   fn foo<'a>(&'a self, x: &'a i32) -> &i32 {
    |               ++           ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-self-is-anon.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-self-is-anon.stderr
index e4c855e11fe..dde271d100c 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-self-is-anon.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-self-is-anon.stderr
@@ -13,5 +13,5 @@ help: consider introducing a named lifetime parameter and update trait if needed
 LL |     fn foo<'a>(&'a self, x: &'a Foo) -> &Foo {
    |                 ++           ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-using-impl-items.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-using-impl-items.stderr
index 9661f1e5144..420cfa6b569 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-using-impl-items.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-using-impl-items.stderr
@@ -13,5 +13,5 @@ help: consider introducing a named lifetime parameter and update trait if needed
 LL |     fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) {
    |           ++++              ++          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions.stderr
index ec9fac0c288..875d22576e5 100644
--- a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions.stderr
@@ -13,5 +13,5 @@ help: consider introducing a named lifetime parameter
 LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) {
    |       ++++              ++          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/lifetime-mismatch-between-trait-and-impl.stderr b/tests/ui/lifetimes/lifetime-mismatch-between-trait-and-impl.stderr
index 9c61d5a0c25..917d204367f 100644
--- a/tests/ui/lifetimes/lifetime-mismatch-between-trait-and-impl.stderr
+++ b/tests/ui/lifetimes/lifetime-mismatch-between-trait-and-impl.stderr
@@ -12,5 +12,5 @@ LL |     fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
    = help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
    = help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/nested-binder-print.stderr b/tests/ui/lifetimes/nested-binder-print.stderr
index 32dd896932d..fb93b7855a4 100644
--- a/tests/ui/lifetimes/nested-binder-print.stderr
+++ b/tests/ui/lifetimes/nested-binder-print.stderr
@@ -9,6 +9,6 @@ LL |     let x: u32 = y;
    = note:    expected type `u32`
            found fn pointer `for<'a> fn(for<'b> fn(TwoLt<'b, 'a>))`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lifetimes/re-empty-in-error.stderr b/tests/ui/lifetimes/re-empty-in-error.stderr
index c35d8ecec5e..554bcb5451f 100644
--- a/tests/ui/lifetimes/re-empty-in-error.stderr
+++ b/tests/ui/lifetimes/re-empty-in-error.stderr
@@ -6,5 +6,5 @@ LL |     foo(&10);
    |
    = note: could not prove `for<'b> &'b (): 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr b/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
index 79df2c8dfbc..a491de8ac1e 100644
--- a/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
+++ b/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
@@ -11,6 +11,6 @@ help: consider adding an explicit lifetime bound
 LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
    |                   +++  ++++      ++         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0311`.
diff --git a/tests/ui/lifetimes/unnamed-closure-doesnt-life-long-enough-issue-67634.stderr b/tests/ui/lifetimes/unnamed-closure-doesnt-life-long-enough-issue-67634.stderr
index 4399045098d..3f457da1b47 100644
--- a/tests/ui/lifetimes/unnamed-closure-doesnt-life-long-enough-issue-67634.stderr
+++ b/tests/ui/lifetimes/unnamed-closure-doesnt-life-long-enough-issue-67634.stderr
@@ -16,6 +16,6 @@ help: to force the closure to take ownership of `a` (and any other referenced va
 LL |     [0].iter().flat_map(|a| [0].iter().map(move |_| &a));
    |                                            ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/limits/huge-array-simple-64.stderr b/tests/ui/limits/huge-array-simple-64.stderr
index 5791b6439c9..8d395c3c6a9 100644
--- a/tests/ui/limits/huge-array-simple-64.stderr
+++ b/tests/ui/limits/huge-array-simple-64.stderr
@@ -4,5 +4,5 @@ error: values of the type `[u8; 2305843011361177600]` are too big for the curren
 LL |     let _fat: [u8; (1<<61)+(1<<31)] =
    |         ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/huge-array.stderr b/tests/ui/limits/huge-array.stderr
index 24adb33b088..2ebaf17a138 100644
--- a/tests/ui/limits/huge-array.stderr
+++ b/tests/ui/limits/huge-array.stderr
@@ -4,5 +4,5 @@ error: values of the type `[[u8; 1518599999]; 1518600000]` are too big for the c
 LL |     let s: [T; 1518600000] = [t; 1518600000];
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/huge-enum.stderr b/tests/ui/limits/huge-enum.stderr
index 5e2bda9be50..fcd40607af4 100644
--- a/tests/ui/limits/huge-enum.stderr
+++ b/tests/ui/limits/huge-enum.stderr
@@ -4,5 +4,5 @@ error: values of the type `Option<TYPE>` are too big for the current architectur
 LL |     let big: BIG = None;
    |         ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/huge-struct.stderr b/tests/ui/limits/huge-struct.stderr
index ce14bc5b888..782db20c7f3 100644
--- a/tests/ui/limits/huge-struct.stderr
+++ b/tests/ui/limits/huge-struct.stderr
@@ -4,5 +4,5 @@ error: values of the type `SXX<SXX<SXX<u32>>>` are too big for the current archi
 LL |     let fat: Option<SXX<SXX<SXX<u32>>>> = None;
    |         ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/issue-15919-64.stderr b/tests/ui/limits/issue-15919-64.stderr
index 167272890aa..d1f0cc39c18 100644
--- a/tests/ui/limits/issue-15919-64.stderr
+++ b/tests/ui/limits/issue-15919-64.stderr
@@ -4,5 +4,5 @@ error: values of the type `[usize; usize::MAX]` are too big for the current arch
 LL |     let x = [0usize; 0xffff_ffff_ffff_ffff];
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/issue-17913.stderr b/tests/ui/limits/issue-17913.stderr
index 0d21a42883e..893730cbbd2 100644
--- a/tests/ui/limits/issue-17913.stderr
+++ b/tests/ui/limits/issue-17913.stderr
@@ -1,5 +1,5 @@
 error: values of the type `[&usize; usize::MAX]` are too big for the current architecture
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/issue-55878.stderr b/tests/ui/limits/issue-55878.stderr
index 6b463930b00..97ca0f4fb59 100644
--- a/tests/ui/limits/issue-55878.stderr
+++ b/tests/ui/limits/issue-55878.stderr
@@ -28,6 +28,6 @@ LL |     println!("Size: {}", std::mem::size_of::<[u8; u64::MAX as usize]>());
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
    = note: this note originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/limits/issue-69485-var-size-diffs-too-large.stderr b/tests/ui/limits/issue-69485-var-size-diffs-too-large.stderr
index 44b2be26949..7b9b8f76d0c 100644
--- a/tests/ui/limits/issue-69485-var-size-diffs-too-large.stderr
+++ b/tests/ui/limits/issue-69485-var-size-diffs-too-large.stderr
@@ -4,5 +4,5 @@ error: values of the type `[u8; usize::MAX]` are too big for the current archite
 LL |     Bug::V([0; !0]);
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/issue-75158-64.stderr b/tests/ui/limits/issue-75158-64.stderr
index d5991bcf569..06aad9616cb 100644
--- a/tests/ui/limits/issue-75158-64.stderr
+++ b/tests/ui/limits/issue-75158-64.stderr
@@ -1,4 +1,4 @@
 error: values of the type `[u8; usize::MAX]` are too big for the current architecture
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/linkage-attr/incompatible-flavor.stderr b/tests/ui/linkage-attr/incompatible-flavor.stderr
index aabdd14b69b..a0f6bff6676 100644
--- a/tests/ui/linkage-attr/incompatible-flavor.stderr
+++ b/tests/ui/linkage-attr/incompatible-flavor.stderr
@@ -2,5 +2,5 @@ error: linker flavor `msvc` is incompatible with the current target
    |
    = note: compatible flavors are: gnu, gnu-lld, gnu-cc, gnu-lld-cc, gcc, ld, ld.lld
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/linkage-attr/issue-109144.stderr b/tests/ui/linkage-attr/issue-109144.stderr
index 33187cfdbb6..0748d94189c 100644
--- a/tests/ui/linkage-attr/issue-109144.stderr
+++ b/tests/ui/linkage-attr/issue-109144.stderr
@@ -4,6 +4,6 @@ error[E0459]: `#[link]` attribute requires a `name = "string"` argument
 LL | #[link(kind = "static", modifiers = "+whole-archive,+bundle")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `name` argument
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0459`.
diff --git a/tests/ui/linkage-attr/linkage-detect-extern-generated-name-collision.stderr b/tests/ui/linkage-attr/linkage-detect-extern-generated-name-collision.stderr
index 06a07082263..2448c160c5c 100644
--- a/tests/ui/linkage-attr/linkage-detect-extern-generated-name-collision.stderr
+++ b/tests/ui/linkage-attr/linkage-detect-extern-generated-name-collision.stderr
@@ -4,5 +4,5 @@ error: symbol `collision` is already defined
 LL |     pub static collision: *const i32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/linkage-attr/linkage-detect-local-generated-name-collision.stderr b/tests/ui/linkage-attr/linkage-detect-local-generated-name-collision.stderr
index e0be1ac2117..fcaaa39b674 100644
--- a/tests/ui/linkage-attr/linkage-detect-local-generated-name-collision.stderr
+++ b/tests/ui/linkage-attr/linkage-detect-local-generated-name-collision.stderr
@@ -4,5 +4,5 @@ error: symbol `collision` is already defined
 LL |         pub static collision: *const i32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/linkage-attr/linkage2.stderr b/tests/ui/linkage-attr/linkage2.stderr
index 7265f711fd0..49290d5a13f 100644
--- a/tests/ui/linkage-attr/linkage2.stderr
+++ b/tests/ui/linkage-attr/linkage2.stderr
@@ -4,6 +4,6 @@ error[E0791]: invalid type for variable with `#[linkage]` attribute
 LL |     static foo: i32;
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0791`.
diff --git a/tests/ui/linkage-attr/linkage3.stderr b/tests/ui/linkage-attr/linkage3.stderr
index dbb5880ab92..5f7b7ef227c 100644
--- a/tests/ui/linkage-attr/linkage3.stderr
+++ b/tests/ui/linkage-attr/linkage3.stderr
@@ -4,5 +4,5 @@ error: invalid linkage specified
 LL |     static foo: *const i32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/linkage-attr/linkage4.stderr b/tests/ui/linkage-attr/linkage4.stderr
index 30d4d2b7bba..f76655b3c72 100644
--- a/tests/ui/linkage-attr/linkage4.stderr
+++ b/tests/ui/linkage-attr/linkage4.stderr
@@ -7,6 +7,6 @@ LL | #[linkage = "external"]
    = note: see issue #29603 <https://github.com/rust-lang/rust/issues/29603> for more information
    = help: add `#![feature(linkage)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/lint-group-forbid-always-trumps-cli.stderr b/tests/ui/lint-group-forbid-always-trumps-cli.stderr
index cd042179cce..04a0f56c163 100644
--- a/tests/ui/lint-group-forbid-always-trumps-cli.stderr
+++ b/tests/ui/lint-group-forbid-always-trumps-cli.stderr
@@ -7,5 +7,5 @@ LL |     let x = 1;
    = note: `-F unused-variables` implied by `-F unused`
    = help: to override `-F unused` add `#[allow(unused_variables)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/bad-lint-cap2.stderr b/tests/ui/lint/bad-lint-cap2.stderr
index 3f3affe5a98..05b16b44c53 100644
--- a/tests/ui/lint/bad-lint-cap2.stderr
+++ b/tests/ui/lint/bad-lint-cap2.stderr
@@ -11,5 +11,5 @@ LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(unused_imports)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/bare-trait-objects-path.stderr b/tests/ui/lint/bare-trait-objects-path.stderr
index 01ca08a6f19..c5d72707f80 100644
--- a/tests/ui/lint/bare-trait-objects-path.stderr
+++ b/tests/ui/lint/bare-trait-objects-path.stderr
@@ -57,6 +57,6 @@ help: use `dyn`
 LL |     <dyn Dyn>::CONST;
    |     ++++    +
 
-error: aborting due to previous error; 4 warnings emitted
+error: aborting due to 1 previous error; 4 warnings emitted
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/lint/cli-lint-override.forbid_warn.stderr b/tests/ui/lint/cli-lint-override.forbid_warn.stderr
index d1c66a81cd8..d8c75c33b0c 100644
--- a/tests/ui/lint/cli-lint-override.forbid_warn.stderr
+++ b/tests/ui/lint/cli-lint-override.forbid_warn.stderr
@@ -7,5 +7,5 @@ LL | extern fn foo() {}
    = help: the default ABI is C
    = note: requested on the command line with `-F missing-abi`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/cli-lint-override.warn_deny.stderr b/tests/ui/lint/cli-lint-override.warn_deny.stderr
index f034cfa9338..1ba42e9ce32 100644
--- a/tests/ui/lint/cli-lint-override.warn_deny.stderr
+++ b/tests/ui/lint/cli-lint-override.warn_deny.stderr
@@ -7,5 +7,5 @@ LL | extern fn foo() {}
    = help: the default ABI is C
    = note: requested on the command line with `-D missing-abi`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/command-line-lint-group-deny.stderr b/tests/ui/lint/command-line-lint-group-deny.stderr
index 59d8429ea69..d78f198e732 100644
--- a/tests/ui/lint/command-line-lint-group-deny.stderr
+++ b/tests/ui/lint/command-line-lint-group-deny.stderr
@@ -7,5 +7,5 @@ LL |     let _InappropriateCamelCasing = true;
    = note: `-D non-snake-case` implied by `-D bad-style`
    = help: to override `-D bad-style` add `#[allow(non_snake_case)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/command-line-lint-group-forbid.stderr b/tests/ui/lint/command-line-lint-group-forbid.stderr
index 486d32a9f08..7b527e7b8b4 100644
--- a/tests/ui/lint/command-line-lint-group-forbid.stderr
+++ b/tests/ui/lint/command-line-lint-group-forbid.stderr
@@ -7,5 +7,5 @@ LL |     let _InappropriateCamelCasing = true;
    = note: `-F non-snake-case` implied by `-F bad-style`
    = help: to override `-F bad-style` add `#[allow(non_snake_case)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/basic.stderr b/tests/ui/lint/dead-code/basic.stderr
index 7d068cead44..9f7d25502e7 100644
--- a/tests/ui/lint/dead-code/basic.stderr
+++ b/tests/ui/lint/dead-code/basic.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/closure-bang.stderr b/tests/ui/lint/dead-code/closure-bang.stderr
index 119ce11e34a..a0f5962dfe0 100644
--- a/tests/ui/lint/dead-code/closure-bang.stderr
+++ b/tests/ui/lint/dead-code/closure-bang.stderr
@@ -13,5 +13,5 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/empty-unused-enum.stderr b/tests/ui/lint/dead-code/empty-unused-enum.stderr
index 6391f0941c8..a6bf2e1f436 100644
--- a/tests/ui/lint/dead-code/empty-unused-enum.stderr
+++ b/tests/ui/lint/dead-code/empty-unused-enum.stderr
@@ -11,5 +11,5 @@ LL | #![deny(unused)]
    |         ^^^^^^
    = note: `#[deny(dead_code)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/impl-trait.stderr b/tests/ui/lint/dead-code/impl-trait.stderr
index e35e13a9ec6..1c7d6d94597 100644
--- a/tests/ui/lint/dead-code/impl-trait.stderr
+++ b/tests/ui/lint/dead-code/impl-trait.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/type-alias.stderr b/tests/ui/lint/dead-code/type-alias.stderr
index 446447d974a..87c858fdb2a 100644
--- a/tests/ui/lint/dead-code/type-alias.stderr
+++ b/tests/ui/lint/dead-code/type-alias.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/unused-assoc-fns.stderr b/tests/ui/lint/dead-code/unused-assoc-fns.stderr
index 6344a70ea3a..2e43a67d5c8 100644
--- a/tests/ui/lint/dead-code/unused-assoc-fns.stderr
+++ b/tests/ui/lint/dead-code/unused-assoc-fns.stderr
@@ -25,5 +25,5 @@ LL | #![deny(unused)]
    |         ^^^^^^
    = note: `#[deny(dead_code)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/unused-struct-variant.stderr b/tests/ui/lint/dead-code/unused-struct-variant.stderr
index d26dd3aff95..bd7b4125660 100644
--- a/tests/ui/lint/dead-code/unused-struct-variant.stderr
+++ b/tests/ui/lint/dead-code/unused-struct-variant.stderr
@@ -14,5 +14,5 @@ LL | #![deny(unused)]
    |         ^^^^^^
    = note: `#[deny(dead_code)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/unused-variant.stderr b/tests/ui/lint/dead-code/unused-variant.stderr
index 6029bf26856..0ae15fde47b 100644
--- a/tests/ui/lint/dead-code/unused-variant.stderr
+++ b/tests/ui/lint/dead-code/unused-variant.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/dead-code/with-core-crate.stderr b/tests/ui/lint/dead-code/with-core-crate.stderr
index 7adcf884886..f466a616580 100644
--- a/tests/ui/lint/dead-code/with-core-crate.stderr
+++ b/tests/ui/lint/dead-code/with-core-crate.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/enable-unstable-lib-feature.stderr b/tests/ui/lint/enable-unstable-lib-feature.stderr
index bb4e928ad15..327e6e3e956 100644
--- a/tests/ui/lint/enable-unstable-lib-feature.stderr
+++ b/tests/ui/lint/enable-unstable-lib-feature.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_snake_case)] // To trigger a hard error
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/expr_attr_paren_order.stderr b/tests/ui/lint/expr_attr_paren_order.stderr
index 42beed10c19..b3a3741d245 100644
--- a/tests/ui/lint/expr_attr_paren_order.stderr
+++ b/tests/ui/lint/expr_attr_paren_order.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL |     #[allow(non_snake_case)] #[deny(non_snake_case)] (
    |                                     ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/forbid-group-group-1.stderr b/tests/ui/lint/forbid-group-group-1.stderr
index fd425e5f74e..bbea56ac64a 100644
--- a/tests/ui/lint/forbid-group-group-1.stderr
+++ b/tests/ui/lint/forbid-group-group-1.stderr
@@ -11,5 +11,5 @@ LL | #![forbid(nonstandard_style)]
    |           ^^^^^^^^^^^^^^^^^
    = note: `#[forbid(non_snake_case)]` implied by `#[forbid(nonstandard_style)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/issue-104897.stderr b/tests/ui/lint/issue-104897.stderr
index 728d51f34a4..1f3d40605f6 100644
--- a/tests/ui/lint/issue-104897.stderr
+++ b/tests/ui/lint/issue-104897.stderr
@@ -8,5 +8,5 @@ LL | fn f(){(print!(á
    |       |unclosed delimiter
    |       unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/issue-106991.stderr b/tests/ui/lint/issue-106991.stderr
index 7b43f0b2ca8..4704e9ef835 100644
--- a/tests/ui/lint/issue-106991.stderr
+++ b/tests/ui/lint/issue-106991.stderr
@@ -6,6 +6,6 @@ LL | fn bar() -> impl Iterator<Item = i32> {
    |
    = note: required for `Map<std::slice::IterMut<'_, Vec<u8>>, for<'a> fn(&'a mut Vec<u8>) {foo}>` to implement `Iterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/lint/issue-109152.stderr b/tests/ui/lint/issue-109152.stderr
index 7db9e71a584..a175964ccf6 100644
--- a/tests/ui/lint/issue-109152.stderr
+++ b/tests/ui/lint/issue-109152.stderr
@@ -19,5 +19,5 @@ help: you might have meant to use `Iterator::for_each`
 LL |     vec![42].iter().for_each(drop);
    |                     ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/issue-63364.stderr b/tests/ui/lint/issue-63364.stderr
index 9b5453fa82d..f4305f37fe0 100644
--- a/tests/ui/lint/issue-63364.stderr
+++ b/tests/ui/lint/issue-63364.stderr
@@ -7,5 +7,5 @@ LL |     for n in 100_000.. {
    = note: the literal `100_000` does not fit into the type `u16` whose range is `0..=65535`
    = note: `#[deny(overflowing_literals)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr b/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr
index cc44f8aa58b..f78bf899b84 100644
--- a/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr
+++ b/tests/ui/lint/issue-70819-dont-override-forbid-in-same-scope.stderr
@@ -14,5 +14,5 @@ note: the lint level is defined here
 LL | #![forbid(forbidden_lint_groups)]
    |           ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/issue-79744.stderr b/tests/ui/lint/issue-79744.stderr
index c1b56250d3e..4cb79f7fd29 100644
--- a/tests/ui/lint/issue-79744.stderr
+++ b/tests/ui/lint/issue-79744.stderr
@@ -8,5 +8,5 @@ LL |     let e2 = 230;
    = help: consider using the type `u8` instead
    = note: `#[deny(overflowing_literals)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/issue-99387.stderr b/tests/ui/lint/issue-99387.stderr
index 3a46ce7e195..0005e55324f 100644
--- a/tests/ui/lint/issue-99387.stderr
+++ b/tests/ui/lint/issue-99387.stderr
@@ -11,5 +11,5 @@ note: this item must mention the opaque type in its signature in order to be abl
 LL | pub fn ohno<'a>() -> <&'a () as Tr>::Item {
    |        ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/let_underscore/let_underscore_lock.stderr b/tests/ui/lint/let_underscore/let_underscore_lock.stderr
index fb58af0a42f..f88a1df55e0 100644
--- a/tests/ui/lint/let_underscore/let_underscore_lock.stderr
+++ b/tests/ui/lint/let_underscore/let_underscore_lock.stderr
@@ -16,5 +16,5 @@ help: consider immediately dropping the value
 LL |     drop(data.lock().unwrap());
    |     ~~~~~                    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-attr-non-item-node.stderr b/tests/ui/lint/lint-attr-non-item-node.stderr
index 58357914096..7922d1c084d 100644
--- a/tests/ui/lint/lint-attr-non-item-node.stderr
+++ b/tests/ui/lint/lint-attr-non-item-node.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL |     #[deny(unreachable_code)]
    |            ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-ctypes-73249-2.stderr b/tests/ui/lint/lint-ctypes-73249-2.stderr
index 49fa54114b2..ef30a406969 100644
--- a/tests/ui/lint/lint-ctypes-73249-2.stderr
+++ b/tests/ui/lint/lint-ctypes-73249-2.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-ctypes-73249-3.stderr b/tests/ui/lint/lint-ctypes-73249-3.stderr
index c41ce666db8..e5607ba72e9 100644
--- a/tests/ui/lint/lint-ctypes-73249-3.stderr
+++ b/tests/ui/lint/lint-ctypes-73249-3.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-ctypes-73249-5.stderr b/tests/ui/lint/lint-ctypes-73249-5.stderr
index 98245c4f144..fcb106c485d 100644
--- a/tests/ui/lint/lint-ctypes-73249-5.stderr
+++ b/tests/ui/lint/lint-ctypes-73249-5.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-ctypes-73251-1.stderr b/tests/ui/lint/lint-ctypes-73251-1.stderr
index b4eb921b97e..a3b3ebaac30 100644
--- a/tests/ui/lint/lint-ctypes-73251-1.stderr
+++ b/tests/ui/lint/lint-ctypes-73251-1.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-ctypes-73251-2.stderr b/tests/ui/lint/lint-ctypes-73251-2.stderr
index e44cd45bd30..40a9cd00c50 100644
--- a/tests/ui/lint/lint-ctypes-73251-2.stderr
+++ b/tests/ui/lint/lint-ctypes-73251-2.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr b/tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr
index f59fb3cc750..74630469416 100644
--- a/tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr
+++ b/tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-forbid-internal-unsafe.stderr b/tests/ui/lint/lint-forbid-internal-unsafe.stderr
index ba425ceb442..52d9c8471e5 100644
--- a/tests/ui/lint/lint-forbid-internal-unsafe.stderr
+++ b/tests/ui/lint/lint-forbid-internal-unsafe.stderr
@@ -18,5 +18,5 @@ LL |     println!("{}", evil!(*(0 as *const u8)));
    |
    = note: `#[warn(deref_nullptr)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lint/lint-match-arms.stderr b/tests/ui/lint/lint-match-arms.stderr
index 1bc0e41fd55..eccfa19fda7 100644
--- a/tests/ui/lint/lint-match-arms.stderr
+++ b/tests/ui/lint/lint-match-arms.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL |         #[deny(unused_variables)]
    |                ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-missing-copy-implementations.stderr b/tests/ui/lint/lint-missing-copy-implementations.stderr
index e5f5ce20d1c..37c9192d2a4 100644
--- a/tests/ui/lint/lint-missing-copy-implementations.stderr
+++ b/tests/ui/lint/lint-missing-copy-implementations.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(missing_copy_implementations)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-non-snake-case-crate-2.stderr b/tests/ui/lint/lint-non-snake-case-crate-2.stderr
index 4b42145bbed..f3207226cd9 100644
--- a/tests/ui/lint/lint-non-snake-case-crate-2.stderr
+++ b/tests/ui/lint/lint-non-snake-case-crate-2.stderr
@@ -7,5 +7,5 @@ note: the lint level is defined here
 LL | #![deny(non_snake_case)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-non-snake-case-crate.stderr b/tests/ui/lint/lint-non-snake-case-crate.stderr
index da6b89c1e04..1136b707d59 100644
--- a/tests/ui/lint/lint-non-snake-case-crate.stderr
+++ b/tests/ui/lint/lint-non-snake-case-crate.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_snake_case)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-non-snake-case-lifetimes.stderr b/tests/ui/lint/lint-non-snake-case-lifetimes.stderr
index d4fe26a43c2..8be7365cfc3 100644
--- a/tests/ui/lint/lint-non-snake-case-lifetimes.stderr
+++ b/tests/ui/lint/lint-non-snake-case-lifetimes.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_snake_case)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-non-snake-case-modules.stderr b/tests/ui/lint/lint-non-snake-case-modules.stderr
index c8b997c8707..f21f9a934f3 100644
--- a/tests/ui/lint/lint-non-snake-case-modules.stderr
+++ b/tests/ui/lint/lint-non-snake-case-modules.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_snake_case)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-non-uppercase-associated-const.stderr b/tests/ui/lint/lint-non-uppercase-associated-const.stderr
index 411ff51aad7..54c951b1f63 100644
--- a/tests/ui/lint/lint-non-uppercase-associated-const.stderr
+++ b/tests/ui/lint/lint-non-uppercase-associated-const.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_upper_case_globals)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-non-uppercase-trait-assoc-const.stderr b/tests/ui/lint/lint-non-uppercase-trait-assoc-const.stderr
index 98d8d1dd27f..a5ac540d125 100644
--- a/tests/ui/lint/lint-non-uppercase-trait-assoc-const.stderr
+++ b/tests/ui/lint/lint-non-uppercase-trait-assoc-const.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(non_upper_case_globals)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-nonstandard-style-unicode-3.stderr b/tests/ui/lint/lint-nonstandard-style-unicode-3.stderr
index 970e6b838ad..3d4337bbc6f 100644
--- a/tests/ui/lint/lint-nonstandard-style-unicode-3.stderr
+++ b/tests/ui/lint/lint-nonstandard-style-unicode-3.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![forbid(non_upper_case_globals)]
    |           ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-qualification.stderr b/tests/ui/lint/lint-qualification.stderr
index 90a06bc6cbe..2448a64f11d 100644
--- a/tests/ui/lint/lint-qualification.stderr
+++ b/tests/ui/lint/lint-qualification.stderr
@@ -15,5 +15,5 @@ LL -     foo::bar();
 LL +     bar();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-removed-allow.stderr b/tests/ui/lint/lint-removed-allow.stderr
index 029334c2eb6..849c9ec5ca0 100644
--- a/tests/ui/lint/lint-removed-allow.stderr
+++ b/tests/ui/lint/lint-removed-allow.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #[deny(unused_variables)]
    |        ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-removed-cmdline.stderr b/tests/ui/lint/lint-removed-cmdline.stderr
index 6b76ad3b578..fd63433c308 100644
--- a/tests/ui/lint/lint-removed-cmdline.stderr
+++ b/tests/ui/lint/lint-removed-cmdline.stderr
@@ -26,5 +26,5 @@ LL | #[deny(warnings)]
    |        ^^^^^^^^
    = note: `#[deny(unused_variables)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error; 3 warnings emitted
+error: aborting due to 1 previous error; 3 warnings emitted
 
diff --git a/tests/ui/lint/lint-removed.stderr b/tests/ui/lint/lint-removed.stderr
index dc0515b8482..6d3629ba388 100644
--- a/tests/ui/lint/lint-removed.stderr
+++ b/tests/ui/lint/lint-removed.stderr
@@ -18,5 +18,5 @@ note: the lint level is defined here
 LL | #[deny(unused_variables)]
    |        ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lint/lint-renamed-allow.stderr b/tests/ui/lint/lint-renamed-allow.stderr
index 46f6a10de27..8bc8530b422 100644
--- a/tests/ui/lint/lint-renamed-allow.stderr
+++ b/tests/ui/lint/lint-renamed-allow.stderr
@@ -11,5 +11,5 @@ LL | #[deny(unused)]
    |        ^^^^^^
    = note: `#[deny(unused_variables)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-renamed-cmdline.stderr b/tests/ui/lint/lint-renamed-cmdline.stderr
index 675443ddedf..d6bb72f34dc 100644
--- a/tests/ui/lint/lint-renamed-cmdline.stderr
+++ b/tests/ui/lint/lint-renamed-cmdline.stderr
@@ -29,5 +29,5 @@ LL | #[deny(unused)]
    |        ^^^^^^
    = note: `#[deny(unused_variables)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error; 3 warnings emitted
+error: aborting due to 1 previous error; 3 warnings emitted
 
diff --git a/tests/ui/lint/lint-renamed.stderr b/tests/ui/lint/lint-renamed.stderr
index 98425457145..a1aa85e6744 100644
--- a/tests/ui/lint/lint-renamed.stderr
+++ b/tests/ui/lint/lint-renamed.stderr
@@ -19,5 +19,5 @@ LL | #[deny(unused)]
    |        ^^^^^^
    = note: `#[deny(unused_variables)]` implied by `#[deny(unused)]`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lint/lint-stability2.stderr b/tests/ui/lint/lint-stability2.stderr
index 51bdf84a321..3df0c428167 100644
--- a/tests/ui/lint/lint-stability2.stderr
+++ b/tests/ui/lint/lint-stability2.stderr
@@ -11,5 +11,5 @@ LL | #![deny(deprecated)]
    |         ^^^^^^^^^^
    = note: this error originates in the macro `macro_test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-stability3.stderr b/tests/ui/lint/lint-stability3.stderr
index 3bbb60dd359..3a2af452ce2 100644
--- a/tests/ui/lint/lint-stability3.stderr
+++ b/tests/ui/lint/lint-stability3.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(deprecated)]
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-strict-provenance-fuzzy-casts.stderr b/tests/ui/lint/lint-strict-provenance-fuzzy-casts.stderr
index 383623b4831..0b128974275 100644
--- a/tests/ui/lint/lint-strict-provenance-fuzzy-casts.stderr
+++ b/tests/ui/lint/lint-strict-provenance-fuzzy-casts.stderr
@@ -15,5 +15,5 @@ help: use `.with_addr()` to adjust a valid pointer in the same allocation, to th
 LL |     let dangling = (...).with_addr(16_usize);
    |                    ++++++++++++++++        ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-struct-necessary.stderr b/tests/ui/lint/lint-struct-necessary.stderr
index eb65a9e98c6..90b2af7dea9 100644
--- a/tests/ui/lint/lint-struct-necessary.stderr
+++ b/tests/ui/lint/lint-struct-necessary.stderr
@@ -15,5 +15,5 @@ LL -     match (e) {
 LL +     match e {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-temporary-cstring-as-param.stderr b/tests/ui/lint/lint-temporary-cstring-as-param.stderr
index 838b3bc13fe..7aa21f2560c 100644
--- a/tests/ui/lint/lint-temporary-cstring-as-param.stderr
+++ b/tests/ui/lint/lint-temporary-cstring-as-param.stderr
@@ -14,5 +14,5 @@ note: the lint level is defined here
 LL | #![deny(temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-type-limits2.stderr b/tests/ui/lint/lint-type-limits2.stderr
index b3420ad8afd..91363350884 100644
--- a/tests/ui/lint/lint-type-limits2.stderr
+++ b/tests/ui/lint/lint-type-limits2.stderr
@@ -20,5 +20,5 @@ note: the lint level is defined here
 LL | #![warn(overflowing_literals)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lint/lint-type-limits3.stderr b/tests/ui/lint/lint-type-limits3.stderr
index db46e7ae714..77487164a13 100644
--- a/tests/ui/lint/lint-type-limits3.stderr
+++ b/tests/ui/lint/lint-type-limits3.stderr
@@ -20,5 +20,5 @@ note: the lint level is defined here
 LL | #![warn(overflowing_literals)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lint/lint-unconditional-drop-recursion.stderr b/tests/ui/lint/lint-unconditional-drop-recursion.stderr
index 76f95481605..5ac56499c1f 100644
--- a/tests/ui/lint/lint-unconditional-drop-recursion.stderr
+++ b/tests/ui/lint/lint-unconditional-drop-recursion.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unconditional_recursion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/lint-unnecessary-import-braces.stderr b/tests/ui/lint/lint-unnecessary-import-braces.stderr
index 2d289404ded..5f441ef4a66 100644
--- a/tests/ui/lint/lint-unnecessary-import-braces.stderr
+++ b/tests/ui/lint/lint-unnecessary-import-braces.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_import_braces)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/boxed.stderr b/tests/ui/lint/must_not_suspend/boxed.stderr
index a2abfffc170..6170a36a813 100644
--- a/tests/ui/lint/must_not_suspend/boxed.stderr
+++ b/tests/ui/lint/must_not_suspend/boxed.stderr
@@ -22,5 +22,5 @@ note: the lint level is defined here
 LL | #![deny(must_not_suspend)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/dedup.stderr b/tests/ui/lint/must_not_suspend/dedup.stderr
index 5d5b04a5d95..2876e1cf675 100644
--- a/tests/ui/lint/must_not_suspend/dedup.stderr
+++ b/tests/ui/lint/must_not_suspend/dedup.stderr
@@ -18,5 +18,5 @@ note: the lint level is defined here
 LL | #![deny(must_not_suspend)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/feature-gate-must_not_suspend.stderr b/tests/ui/lint/must_not_suspend/feature-gate-must_not_suspend.stderr
index ab20a8be874..9ec33b1c490 100644
--- a/tests/ui/lint/must_not_suspend/feature-gate-must_not_suspend.stderr
+++ b/tests/ui/lint/must_not_suspend/feature-gate-must_not_suspend.stderr
@@ -7,6 +7,6 @@ LL | #[must_not_suspend = "You gotta use Umm's, ya know?"]
    = note: see issue #83310 <https://github.com/rust-lang/rust/issues/83310> for more information
    = help: add `#![feature(must_not_suspend)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/lint/must_not_suspend/mutex.stderr b/tests/ui/lint/must_not_suspend/mutex.stderr
index 9b5fc37a332..ca53a753150 100644
--- a/tests/ui/lint/must_not_suspend/mutex.stderr
+++ b/tests/ui/lint/must_not_suspend/mutex.stderr
@@ -22,5 +22,5 @@ note: the lint level is defined here
 LL | #![deny(must_not_suspend)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/other_items.stderr b/tests/ui/lint/must_not_suspend/other_items.stderr
index 41c8896921b..e6c36b78951 100644
--- a/tests/ui/lint/must_not_suspend/other_items.stderr
+++ b/tests/ui/lint/must_not_suspend/other_items.stderr
@@ -6,5 +6,5 @@ LL | #[must_not_suspend]
 LL | mod inner {}
    | ------------ is not a struct, enum, or trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/ref.stderr b/tests/ui/lint/must_not_suspend/ref.stderr
index ed91a4a0bc6..aa772afc7a9 100644
--- a/tests/ui/lint/must_not_suspend/ref.stderr
+++ b/tests/ui/lint/must_not_suspend/ref.stderr
@@ -23,5 +23,5 @@ note: the lint level is defined here
 LL | #![deny(must_not_suspend)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/return.stderr b/tests/ui/lint/must_not_suspend/return.stderr
index fdada85eb4d..5a73064c787 100644
--- a/tests/ui/lint/must_not_suspend/return.stderr
+++ b/tests/ui/lint/must_not_suspend/return.stderr
@@ -8,5 +8,5 @@ LL | |     0
 LL | | }
    | |_- is not a struct, enum, or trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr b/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr
index 294476107ef..3adf26cfee2 100644
--- a/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr
+++ b/tests/ui/lint/must_not_suspend/tuple-mismatch.stderr
@@ -7,6 +7,6 @@ LL |         yield ((), ());
    = note:  expected tuple `((), ())`
            found unit type `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lint/must_not_suspend/unit.stderr b/tests/ui/lint/must_not_suspend/unit.stderr
index 11c95c1464a..716369d8e6a 100644
--- a/tests/ui/lint/must_not_suspend/unit.stderr
+++ b/tests/ui/lint/must_not_suspend/unit.stderr
@@ -22,5 +22,5 @@ note: the lint level is defined here
 LL | #![deny(must_not_suspend)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/opaque-ty-ffi-normalization-cycle.stderr b/tests/ui/lint/opaque-ty-ffi-normalization-cycle.stderr
index e8d696477ad..9efc187833f 100644
--- a/tests/ui/lint/opaque-ty-ffi-normalization-cycle.stderr
+++ b/tests/ui/lint/opaque-ty-ffi-normalization-cycle.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/opaque-ty-ffi-unsafe.stderr b/tests/ui/lint/opaque-ty-ffi-unsafe.stderr
index ba9e18bcce5..7f5d1792bf1 100644
--- a/tests/ui/lint/opaque-ty-ffi-unsafe.stderr
+++ b/tests/ui/lint/opaque-ty-ffi-unsafe.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/renamed-lints-still-apply.stderr b/tests/ui/lint/renamed-lints-still-apply.stderr
index e926719bb6b..9eaf7112933 100644
--- a/tests/ui/lint/renamed-lints-still-apply.stderr
+++ b/tests/ui/lint/renamed-lints-still-apply.stderr
@@ -25,5 +25,5 @@ LL - fn _foo<'a>(_x: &'a u32) {}
 LL + fn _foo(_x: &u32) {}
    |
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lint/rfc-2383-lint-reason/expect_missing_feature_gate.stderr b/tests/ui/lint/rfc-2383-lint-reason/expect_missing_feature_gate.stderr
index b5601cf9e65..b8e7d61a1ec 100644
--- a/tests/ui/lint/rfc-2383-lint-reason/expect_missing_feature_gate.stderr
+++ b/tests/ui/lint/rfc-2383-lint-reason/expect_missing_feature_gate.stderr
@@ -7,6 +7,6 @@ LL | #[expect(unused)]
    = note: see issue #54503 <https://github.com/rust-lang/rust/issues/54503> for more information
    = help: add `#![feature(lint_reasons)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/lint/rfc-2383-lint-reason/expect_nested_lint_levels.stderr b/tests/ui/lint/rfc-2383-lint-reason/expect_nested_lint_levels.stderr
index 4852c331396..0e445d2439b 100644
--- a/tests/ui/lint/rfc-2383-lint-reason/expect_nested_lint_levels.stderr
+++ b/tests/ui/lint/rfc-2383-lint-reason/expect_nested_lint_levels.stderr
@@ -48,5 +48,5 @@ warning: this lint expectation is unfulfilled
 LL | #[expect(unused_variables)]
    |          ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 4 warnings emitted
+error: aborting due to 1 previous error; 4 warnings emitted
 
diff --git a/tests/ui/lint/rustdoc-renamed.stderr b/tests/ui/lint/rustdoc-renamed.stderr
index 096e867aa16..8491a432756 100644
--- a/tests/ui/lint/rustdoc-renamed.stderr
+++ b/tests/ui/lint/rustdoc-renamed.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(renamed_and_removed_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unaligned_references_external_macro.stderr b/tests/ui/lint/unaligned_references_external_macro.stderr
index 94a95c1d8fd..9945c78e8ba 100644
--- a/tests/ui/lint/unaligned_references_external_macro.stderr
+++ b/tests/ui/lint/unaligned_references_external_macro.stderr
@@ -14,6 +14,6 @@ LL | | }
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
    = note: this error originates in the macro `unaligned_references_external_crate::mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0793`.
diff --git a/tests/ui/lint/unconditional_panic_98444.stderr b/tests/ui/lint/unconditional_panic_98444.stderr
index a347458097f..29719b2dad5 100644
--- a/tests/ui/lint/unconditional_panic_98444.stderr
+++ b/tests/ui/lint/unconditional_panic_98444.stderr
@@ -6,5 +6,5 @@ LL |     let _ = xs[7];
    |
    = note: `#[deny(unconditional_panic)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/issue-105061.stderr b/tests/ui/lint/unused/issue-105061.stderr
index f07aa2012df..b41f14d82eb 100644
--- a/tests/ui/lint/unused/issue-105061.stderr
+++ b/tests/ui/lint/unused/issue-105061.stderr
@@ -16,5 +16,5 @@ LL -     ((for<'a> fn(Inv<'a>)),): Trait,
 LL +     (for<'a> fn(Inv<'a>),): Trait,
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/issue-30730.stderr b/tests/ui/lint/unused/issue-30730.stderr
index b299e99a3a9..c815045df88 100644
--- a/tests/ui/lint/unused/issue-30730.stderr
+++ b/tests/ui/lint/unused/issue-30730.stderr
@@ -11,5 +11,5 @@ LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(unused_imports)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/issue-46576.stderr b/tests/ui/lint/unused/issue-46576.stderr
index 6f4d97068b3..44e4fb582b5 100644
--- a/tests/ui/lint/unused/issue-46576.stderr
+++ b/tests/ui/lint/unused/issue-46576.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_imports)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/issue-59896.stderr b/tests/ui/lint/unused/issue-59896.stderr
index 95b7938ae03..3e8298c6b72 100644
--- a/tests/ui/lint/unused/issue-59896.stderr
+++ b/tests/ui/lint/unused/issue-59896.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unused_imports)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/issue-85913.stderr b/tests/ui/lint/unused/issue-85913.stderr
index 8234ed3b167..b69ac3d97fd 100644
--- a/tests/ui/lint/unused/issue-85913.stderr
+++ b/tests/ui/lint/unused/issue-85913.stderr
@@ -14,5 +14,5 @@ help: use `let _ = ...` to ignore the resulting value
 LL |     let _ = function() && return 1;
    |     +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/lint-unused-mut-variables.stderr b/tests/ui/lint/unused/lint-unused-mut-variables.stderr
index 5f66c031581..dcda1e5306f 100644
--- a/tests/ui/lint/unused/lint-unused-mut-variables.stderr
+++ b/tests/ui/lint/unused/lint-unused-mut-variables.stderr
@@ -226,5 +226,5 @@ LL | fn write_through_reference(mut arg: &mut Arg) {
    |                            |
    |                            help: remove this `mut`
 
-error: aborting due to previous error; 26 warnings emitted
+error: aborting due to 1 previous error; 26 warnings emitted
 
diff --git a/tests/ui/lint/unused/unused-macro-rules-malformed-rule.stderr b/tests/ui/lint/unused/unused-macro-rules-malformed-rule.stderr
index 797c867103f..76b2a055639 100644
--- a/tests/ui/lint/unused/unused-macro-rules-malformed-rule.stderr
+++ b/tests/ui/lint/unused/unused-macro-rules-malformed-rule.stderr
@@ -4,5 +4,5 @@ error: macro rhs must be delimited
 LL |     () => 0;
    |           ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/unused-macro-with-bad-frag-spec.stderr b/tests/ui/lint/unused/unused-macro-with-bad-frag-spec.stderr
index 6edf0a2cf8d..f027e169b42 100644
--- a/tests/ui/lint/unused/unused-macro-with-bad-frag-spec.stderr
+++ b/tests/ui/lint/unused/unused-macro-with-bad-frag-spec.stderr
@@ -6,5 +6,5 @@ LL |     ($wrong:t_ty) => ()
    |
    = help: valid fragment specifiers are `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, `path`, `meta`, `tt`, `item` and `vis`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/unused-macro-with-follow-violation.stderr b/tests/ui/lint/unused/unused-macro-with-follow-violation.stderr
index 5eced4f06c0..a8a41e08129 100644
--- a/tests/ui/lint/unused/unused-macro-with-follow-violation.stderr
+++ b/tests/ui/lint/unused/unused-macro-with-follow-violation.stderr
@@ -6,5 +6,5 @@ LL |     ($e:expr +) => ()
    |
    = note: allowed there are: `=>`, `,` or `;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/unused-mut-warning-captured-var.stderr b/tests/ui/lint/unused/unused-mut-warning-captured-var.stderr
index 20aeedcc241..d4fa96c10a2 100644
--- a/tests/ui/lint/unused/unused-mut-warning-captured-var.stderr
+++ b/tests/ui/lint/unused/unused-mut-warning-captured-var.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![forbid(unused_mut)]
    |           ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused/unused-supertrait.stderr b/tests/ui/lint/unused/unused-supertrait.stderr
index cb45add9c2b..c7ccf30ea24 100644
--- a/tests/ui/lint/unused/unused-supertrait.stderr
+++ b/tests/ui/lint/unused/unused-supertrait.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(unused_must_use)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused_parens_json_suggestion.stderr b/tests/ui/lint/unused_parens_json_suggestion.stderr
index ac3b2b5b21a..4bdfee9159b 100644
--- a/tests/ui/lint/unused_parens_json_suggestion.stderr
+++ b/tests/ui/lint/unused_parens_json_suggestion.stderr
@@ -16,6 +16,6 @@ LL +     let _a = 1 / (2 + 3);
    |
 
 "}
-{"$message_type":"diagnostic","message":"aborting due to previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to previous error
+{"$message_type":"diagnostic","message":"aborting due to 1 previous error","code":null,"level":"error","spans":[],"children":[],"rendered":"error: aborting due to 1 previous error
 
 "}
diff --git a/tests/ui/lint/unused_parens_multibyte_recovery.stderr b/tests/ui/lint/unused_parens_multibyte_recovery.stderr
index adbf27fcca2..ef4089f31f4 100644
--- a/tests/ui/lint/unused_parens_multibyte_recovery.stderr
+++ b/tests/ui/lint/unused_parens_multibyte_recovery.stderr
@@ -8,5 +8,5 @@ LL | fn f(){(print!(á
    |       |unclosed delimiter
    |       unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/unused_variables-issue-82488.stderr b/tests/ui/lint/unused_variables-issue-82488.stderr
index dce03a0f738..3babc94b4eb 100644
--- a/tests/ui/lint/unused_variables-issue-82488.stderr
+++ b/tests/ui/lint/unused_variables-issue-82488.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-loop.stderr b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-loop.stderr
index 66cdce7dacf..f0174560fd5 100644
--- a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-loop.stderr
+++ b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-loop.stderr
@@ -7,6 +7,6 @@ LL |     let v: isize;
 LL |         v = 1;
    |         ^^^^^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-op-eq.stderr b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-op-eq.stderr
index 5db9539cbf1..578a40e4070 100644
--- a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-op-eq.stderr
+++ b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-in-op-eq.stderr
@@ -9,6 +9,6 @@ LL |     v = 2;
 LL |     v += 1;
    |     ^^^^^^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-drop.stderr b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-drop.stderr
index bb7e7e27a4c..2f55b50f0ba 100644
--- a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-drop.stderr
+++ b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-drop.stderr
@@ -10,6 +10,6 @@ LL |     let b = Box::new(1);
 LL |     b = Box::new(2);
    |     ^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-init.stderr b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-init.stderr
index 80458a70a01..8eb71cd99bf 100644
--- a/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-init.stderr
+++ b/tests/ui/liveness/liveness-assign/liveness-assign-imm-local-with-init.stderr
@@ -10,6 +10,6 @@ LL |     let v: isize = 1;
 LL |     v = 2;
    |     ^^^^^ cannot assign twice to immutable variable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/liveness/liveness-closure-require-ret.stderr b/tests/ui/liveness/liveness-closure-require-ret.stderr
index 07b2ef6cd1b..b5d48f4985e 100644
--- a/tests/ui/liveness/liveness-closure-require-ret.stderr
+++ b/tests/ui/liveness/liveness-closure-require-ret.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL | fn main() { println!("{}", force(|| {})); }
    |                                     ^^ expected `isize`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/liveness/liveness-forgot-ret.stderr b/tests/ui/liveness/liveness-forgot-ret.stderr
index ddbdbdb0fd0..a5adadca26e 100644
--- a/tests/ui/liveness/liveness-forgot-ret.stderr
+++ b/tests/ui/liveness/liveness-forgot-ret.stderr
@@ -11,6 +11,6 @@ help: consider returning the local binding `a`
 LL | fn f(a: isize) -> isize { if god_exists(a) { return 5; }; a }
    |                                                           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/liveness/liveness-issue-2163.stderr b/tests/ui/liveness/liveness-issue-2163.stderr
index 2adc2d43809..216469bf6ab 100644
--- a/tests/ui/liveness/liveness-issue-2163.stderr
+++ b/tests/ui/liveness/liveness-issue-2163.stderr
@@ -7,6 +7,6 @@ LL | |
 LL | |     });
    | |_____^ expected `bool`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/liveness/liveness-missing-ret2.stderr b/tests/ui/liveness/liveness-missing-ret2.stderr
index afdb733cd03..8fe999e02e3 100644
--- a/tests/ui/liveness/liveness-missing-ret2.stderr
+++ b/tests/ui/liveness/liveness-missing-ret2.stderr
@@ -6,6 +6,6 @@ LL | fn f() -> isize {
    |    |
    |    implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/liveness/liveness-move-call-arg-2.stderr b/tests/ui/liveness/liveness-move-call-arg-2.stderr
index 479a086a80c..f4252e1ac33 100644
--- a/tests/ui/liveness/liveness-move-call-arg-2.stderr
+++ b/tests/ui/liveness/liveness-move-call-arg-2.stderr
@@ -21,6 +21,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |             take(x.clone());
    |                   ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/liveness/liveness-move-call-arg.stderr b/tests/ui/liveness/liveness-move-call-arg.stderr
index d14cd6cb4e0..9697ed5cb11 100644
--- a/tests/ui/liveness/liveness-move-call-arg.stderr
+++ b/tests/ui/liveness/liveness-move-call-arg.stderr
@@ -21,6 +21,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         take(x.clone());
    |               ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/liveness/liveness-move-in-loop.stderr b/tests/ui/liveness/liveness-move-in-loop.stderr
index a060914f178..7180eb23bf5 100644
--- a/tests/ui/liveness/liveness-move-in-loop.stderr
+++ b/tests/ui/liveness/liveness-move-in-loop.stderr
@@ -21,6 +21,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |                     x = y.clone();
    |                          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/liveness/liveness-move-in-while.stderr b/tests/ui/liveness/liveness-move-in-while.stderr
index 4dff7447dd7..dc48c4cc9ac 100644
--- a/tests/ui/liveness/liveness-move-in-while.stderr
+++ b/tests/ui/liveness/liveness-move-in-while.stderr
@@ -41,6 +41,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         while true { while true { while true { x = y.clone(); x.clone(); } } }
    |                                                     ++++++++
 
-error: aborting due to previous error; 3 warnings emitted
+error: aborting due to 1 previous error; 3 warnings emitted
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/liveness/liveness-use-after-move.stderr b/tests/ui/liveness/liveness-use-after-move.stderr
index 3accba197a1..eab51edca37 100644
--- a/tests/ui/liveness/liveness-use-after-move.stderr
+++ b/tests/ui/liveness/liveness-use-after-move.stderr
@@ -15,6 +15,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     let y = x.clone();
    |              ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/liveness/liveness-use-after-send.stderr b/tests/ui/liveness/liveness-use-after-send.stderr
index 65d55ca8f70..2323451a7d2 100644
--- a/tests/ui/liveness/liveness-use-after-send.stderr
+++ b/tests/ui/liveness/liveness-use-after-send.stderr
@@ -19,6 +19,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     send(ch, message.clone());
    |                     ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/loops/issue-82916.stderr b/tests/ui/loops/issue-82916.stderr
index e6a60d7bc40..5a5e9c4f0bb 100644
--- a/tests/ui/loops/issue-82916.stderr
+++ b/tests/ui/loops/issue-82916.stderr
@@ -16,6 +16,6 @@ help: consider iterating over a slice of the `Vec<S>`'s content to avoid moving
 LL |     for y in &x {
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/loops/loop-break-value-no-repeat.stderr b/tests/ui/loops/loop-break-value-no-repeat.stderr
index 605a1841cf3..946057d0543 100644
--- a/tests/ui/loops/loop-break-value-no-repeat.stderr
+++ b/tests/ui/loops/loop-break-value-no-repeat.stderr
@@ -11,6 +11,6 @@ help: use `break` on its own without a value inside this `for` loop
 LL |         break
    |         ~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0571`.
diff --git a/tests/ui/loops/loop-else-break-with-value.stderr b/tests/ui/loops/loop-else-break-with-value.stderr
index 972e2d341ec..c933e0d0cd8 100644
--- a/tests/ui/loops/loop-else-break-with-value.stderr
+++ b/tests/ui/loops/loop-else-break-with-value.stderr
@@ -14,5 +14,5 @@ LL | |     };
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/loops/loop-else-err.stderr b/tests/ui/loops/loop-else-err.stderr
index c2c5c84cded..c1cbd544afd 100644
--- a/tests/ui/loops/loop-else-err.stderr
+++ b/tests/ui/loops/loop-else-err.stderr
@@ -13,5 +13,5 @@ LL | |     }
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/loops/loop-else-let-else-err.stderr b/tests/ui/loops/loop-else-let-else-err.stderr
index a57c784ff6f..6ee77fb47af 100644
--- a/tests/ui/loops/loop-else-let-else-err.stderr
+++ b/tests/ui/loops/loop-else-let-else-err.stderr
@@ -13,5 +13,5 @@ LL | |     };
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/loops/loop-proper-liveness.stderr b/tests/ui/loops/loop-proper-liveness.stderr
index f9d94b6810c..bcd6eb353e5 100644
--- a/tests/ui/loops/loop-proper-liveness.stderr
+++ b/tests/ui/loops/loop-proper-liveness.stderr
@@ -13,6 +13,6 @@ help: consider assigning a value
 LL |     let x: i32 = 0;
    |                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/loops/loop-properly-diverging-2.stderr b/tests/ui/loops/loop-properly-diverging-2.stderr
index 1d1ae60cda1..c9f27a6a672 100644
--- a/tests/ui/loops/loop-properly-diverging-2.stderr
+++ b/tests/ui/loops/loop-properly-diverging-2.stderr
@@ -12,6 +12,6 @@ help: give it a value of the expected type
 LL |   let x: i32 = loop { break 42 };
    |                             ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lto/issue-11154.stderr b/tests/ui/lto/issue-11154.stderr
index 8eec8b37c85..4d52f6c0f3d 100644
--- a/tests/ui/lto/issue-11154.stderr
+++ b/tests/ui/lto/issue-11154.stderr
@@ -2,5 +2,5 @@ error: cannot prefer dynamic linking when performing LTO
 
 note: only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lto/lto-duplicate-symbols.stderr b/tests/ui/lto/lto-duplicate-symbols.stderr
index f66afa94f4d..7e421845258 100644
--- a/tests/ui/lto/lto-duplicate-symbols.stderr
+++ b/tests/ui/lto/lto-duplicate-symbols.stderr
@@ -2,5 +2,5 @@ warning: Linking globals named 'foo': symbol multiply defined!
 
 error: failed to load bitcode of module "lto-duplicate-symbols2.lto_duplicate_symbols2.HASH-cgu.0.rcgu.o": 
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.leak.stderr b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.leak.stderr
index dd0fdf3a12a..c3d7960de56 100644
--- a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.leak.stderr
+++ b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.leak.stderr
@@ -15,6 +15,6 @@ LL | |     };
    = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
               found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.noleak.stderr b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.noleak.stderr
index cb046d0b0ac..8e4a514c7c6 100644
--- a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.noleak.stderr
+++ b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.noleak.stderr
@@ -7,6 +7,6 @@ LL |         _ => y,
    = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
               found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lub-glb/old-lub-glb-hr-noteq2.leak.stderr b/tests/ui/lub-glb/old-lub-glb-hr-noteq2.leak.stderr
index e54fcf068d8..a1958cc436a 100644
--- a/tests/ui/lub-glb/old-lub-glb-hr-noteq2.leak.stderr
+++ b/tests/ui/lub-glb/old-lub-glb-hr-noteq2.leak.stderr
@@ -14,6 +14,6 @@ LL | |     };
    = note: expected fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
               found fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/macros/bad-concat.stderr b/tests/ui/macros/bad-concat.stderr
index d67f3c33d36..85f5994c720 100644
--- a/tests/ui/macros/bad-concat.stderr
+++ b/tests/ui/macros/bad-concat.stderr
@@ -6,5 +6,5 @@ LL |     let _ = concat!(x, y, z, "bar");
    |
    = note: only literals (like `"foo"`, `-42` and `3.14`) can be passed to `concat!()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/bang-after-name.stderr b/tests/ui/macros/bang-after-name.stderr
index f609c4943ef..27853161e4f 100644
--- a/tests/ui/macros/bang-after-name.stderr
+++ b/tests/ui/macros/bang-after-name.stderr
@@ -4,5 +4,5 @@ error: macro names aren't followed by a `!`
 LL | macro_rules! foo! {
    |                 ^ help: remove the `!`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/best-failure.stderr b/tests/ui/macros/best-failure.stderr
index a52fc5e3da6..c5f8b9abc19 100644
--- a/tests/ui/macros/best-failure.stderr
+++ b/tests/ui/macros/best-failure.stderr
@@ -17,5 +17,5 @@ LL |     (neg false, $self:ident) => { $self };
    |                 ^^^^^^^^^^^
    = note: this error originates in the macro `number` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/derive-in-eager-expansion-hang.stderr b/tests/ui/macros/derive-in-eager-expansion-hang.stderr
index e0a4f3878d8..e0f6d5b2de0 100644
--- a/tests/ui/macros/derive-in-eager-expansion-hang.stderr
+++ b/tests/ui/macros/derive-in-eager-expansion-hang.stderr
@@ -18,5 +18,5 @@ help: you might be missing a string literal to format with
 LL |     format_args!("{}", hang!());
    |                  +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/duplicate-builtin.stderr b/tests/ui/macros/duplicate-builtin.stderr
index 58accea27bb..887a4fbbdc8 100644
--- a/tests/ui/macros/duplicate-builtin.stderr
+++ b/tests/ui/macros/duplicate-builtin.stderr
@@ -16,6 +16,6 @@ LL | |     /* compiler built-in */
 LL | | }
    | |_^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0773`.
diff --git a/tests/ui/macros/include-single-expr.stderr b/tests/ui/macros/include-single-expr.stderr
index 80eecf8f1b9..e99109e1172 100644
--- a/tests/ui/macros/include-single-expr.stderr
+++ b/tests/ui/macros/include-single-expr.stderr
@@ -6,5 +6,5 @@ LL | 10
    |
    = note: `#[deny(incomplete_include)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-100199.stderr b/tests/ui/macros/issue-100199.stderr
index 89a6f585ce4..89c634ce4f0 100644
--- a/tests/ui/macros/issue-100199.stderr
+++ b/tests/ui/macros/issue-100199.stderr
@@ -10,6 +10,6 @@ help: consider importing this trait
 LL + use traits::MyTrait;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/macros/issue-102878.stderr b/tests/ui/macros/issue-102878.stderr
index 034e3731b87..1971a6bd12e 100644
--- a/tests/ui/macros/issue-102878.stderr
+++ b/tests/ui/macros/issue-102878.stderr
@@ -7,5 +7,5 @@ LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
    |                                  |unclosed delimiter
    |                                  closing delimiter possibly meant for this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-105011.stderr b/tests/ui/macros/issue-105011.stderr
index e898af7faa3..ae59102684d 100644
--- a/tests/ui/macros/issue-105011.stderr
+++ b/tests/ui/macros/issue-105011.stderr
@@ -4,5 +4,5 @@ error: suffixes on string literals are invalid
 LL |     println!(""y);
    |              ^^^ invalid suffix `y`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-109237.stderr b/tests/ui/macros/issue-109237.stderr
index d125cff63ea..a335786df86 100644
--- a/tests/ui/macros/issue-109237.stderr
+++ b/tests/ui/macros/issue-109237.stderr
@@ -14,5 +14,5 @@ help: surround the macro invocation with `{}` to interpret the expansion as a st
 LL |     let _ = { statement!(); };
    |             ~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-16098.stderr b/tests/ui/macros/issue-16098.stderr
index 64280219d75..a7249981648 100644
--- a/tests/ui/macros/issue-16098.stderr
+++ b/tests/ui/macros/issue-16098.stderr
@@ -10,5 +10,5 @@ LL |     println!("Problem 1: {}", prob1!(1000));
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_16098`)
    = note: this error originates in the macro `prob1` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-19163.stderr b/tests/ui/macros/issue-19163.stderr
index af509aa59d4..95af07d82d8 100644
--- a/tests/ui/macros/issue-19163.stderr
+++ b/tests/ui/macros/issue-19163.stderr
@@ -4,6 +4,6 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     mywrite!(&v, "Hello world");
    |              ^^ cannot borrow as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/macros/issue-21356.stderr b/tests/ui/macros/issue-21356.stderr
index 17014c6ceee..dd09da6df4f 100644
--- a/tests/ui/macros/issue-21356.stderr
+++ b/tests/ui/macros/issue-21356.stderr
@@ -6,5 +6,5 @@ LL | macro_rules! test { ($wrong:t_ty ..) => () }
    |
    = help: valid fragment specifiers are `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, `path`, `meta`, `tt`, `item` and `vis`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-26094.stderr b/tests/ui/macros/issue-26094.stderr
index ecdf48470f7..0b614e3e5f8 100644
--- a/tests/ui/macros/issue-26094.stderr
+++ b/tests/ui/macros/issue-26094.stderr
@@ -13,6 +13,6 @@ note: function defined here
 LL | fn some_function() {}
    |    ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/macros/issue-29084.stderr b/tests/ui/macros/issue-29084.stderr
index f83e192130b..9c33e4e8427 100644
--- a/tests/ui/macros/issue-29084.stderr
+++ b/tests/ui/macros/issue-29084.stderr
@@ -19,6 +19,6 @@ LL |     foo!(0u8);
    |     --------- in this macro invocation
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/macros/issue-35450.stderr b/tests/ui/macros/issue-35450.stderr
index f2065689f44..6f06df3861d 100644
--- a/tests/ui/macros/issue-35450.stderr
+++ b/tests/ui/macros/issue-35450.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `$`
 LL |     m!($t);
    |        ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-39388.stderr b/tests/ui/macros/issue-39388.stderr
index 62e7dff5476..c94662c2d7f 100644
--- a/tests/ui/macros/issue-39388.stderr
+++ b/tests/ui/macros/issue-39388.stderr
@@ -4,5 +4,5 @@ error: expected one of: `*`, `+`, or `?`
 LL |     (($($a:tt)*) = ($($b:tt))*) => {
    |                      ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-39404.stderr b/tests/ui/macros/issue-39404.stderr
index 3886a70bb15..33cafd93a40 100644
--- a/tests/ui/macros/issue-39404.stderr
+++ b/tests/ui/macros/issue-39404.stderr
@@ -8,5 +8,5 @@ LL | macro_rules! m { ($i) => {} }
    = note: for more information, see issue #40107 <https://github.com/rust-lang/rust/issues/40107>
    = note: `#[deny(missing_fragment_specifier)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-41776.stderr b/tests/ui/macros/issue-41776.stderr
index e06873b5026..ea926e0103a 100644
--- a/tests/ui/macros/issue-41776.stderr
+++ b/tests/ui/macros/issue-41776.stderr
@@ -4,5 +4,5 @@ error: argument must be a string literal
 LL |     include!(line!());
    |              ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-42954.stderr b/tests/ui/macros/issue-42954.stderr
index 396a91994eb..d5a8a117f9a 100644
--- a/tests/ui/macros/issue-42954.stderr
+++ b/tests/ui/macros/issue-42954.stderr
@@ -15,5 +15,5 @@ help: try comparing the cast value
 LL |         ($i as u32) < 0
    |         +         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-54441.stderr b/tests/ui/macros/issue-54441.stderr
index bbbca211b8d..fb2c103139b 100644
--- a/tests/ui/macros/issue-54441.stderr
+++ b/tests/ui/macros/issue-54441.stderr
@@ -9,5 +9,5 @@ LL |     m!();
    |
    = note: the usage of `m!` is likely invalid in foreign item context
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-58490.stderr b/tests/ui/macros/issue-58490.stderr
index b1f0896f3b6..4e796333748 100644
--- a/tests/ui/macros/issue-58490.stderr
+++ b/tests/ui/macros/issue-58490.stderr
@@ -9,6 +9,6 @@ LL |     macro_rules! b { () => () }
    |
    = note: `b` must be defined only once in the macro namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/macros/issue-61053-duplicate-binder.stderr b/tests/ui/macros/issue-61053-duplicate-binder.stderr
index 5a2af45d077..7c7cb26b407 100644
--- a/tests/ui/macros/issue-61053-duplicate-binder.stderr
+++ b/tests/ui/macros/issue-61053-duplicate-binder.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(meta_variable_misuse)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-6596-1.stderr b/tests/ui/macros/issue-6596-1.stderr
index 7ab3685c5cb..f20d67329db 100644
--- a/tests/ui/macros/issue-6596-1.stderr
+++ b/tests/ui/macros/issue-6596-1.stderr
@@ -9,5 +9,5 @@ LL |     e!(foo);
    |
    = note: this error originates in the macro `e` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-78325-inconsistent-resolution.stderr b/tests/ui/macros/issue-78325-inconsistent-resolution.stderr
index 53a0a0793b2..b75e4a9c9e0 100644
--- a/tests/ui/macros/issue-78325-inconsistent-resolution.stderr
+++ b/tests/ui/macros/issue-78325-inconsistent-resolution.stderr
@@ -9,5 +9,5 @@ LL | define_other_core!();
    |
    = note: this error originates in the macro `define_other_core` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-83340.stderr b/tests/ui/macros/issue-83340.stderr
index 1935de02b57..0a083ec1d9c 100644
--- a/tests/ui/macros/issue-83340.stderr
+++ b/tests/ui/macros/issue-83340.stderr
@@ -4,5 +4,5 @@ error: 1 positional argument in format string, but no arguments were given
 LL | \n {} │",
    |    ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-83344.stderr b/tests/ui/macros/issue-83344.stderr
index 1ef70f87a1f..9c404aeb429 100644
--- a/tests/ui/macros/issue-83344.stderr
+++ b/tests/ui/macros/issue-83344.stderr
@@ -4,5 +4,5 @@ error: 1 positional argument in format string, but no arguments were given
 LL |     println!("{}\
    |               ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-84195-lint-anon-const.stderr b/tests/ui/macros/issue-84195-lint-anon-const.stderr
index 29ccd17e069..d9042adfc37 100644
--- a/tests/ui/macros/issue-84195-lint-anon-const.stderr
+++ b/tests/ui/macros/issue-84195-lint-anon-const.stderr
@@ -16,7 +16,7 @@ LL | #![deny(semicolon_in_expressions_from_macros)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `len` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 Future incompatibility report: Future breakage diagnostic:
 error: trailing semicolon in macro used in expression position
diff --git a/tests/ui/macros/issue-84632-eager-expansion-recursion-limit.stderr b/tests/ui/macros/issue-84632-eager-expansion-recursion-limit.stderr
index e266617bd22..c395e0c9100 100644
--- a/tests/ui/macros/issue-84632-eager-expansion-recursion-limit.stderr
+++ b/tests/ui/macros/issue-84632-eager-expansion-recursion-limit.stderr
@@ -10,5 +10,5 @@ LL |     a!(A, A, A, A, A, A, A, A, A, A, A);
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "30"]` attribute to your crate (`issue_84632_eager_expansion_recursion_limit`)
    = note: this error originates in the macro `a` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/issue-92267.stderr b/tests/ui/macros/issue-92267.stderr
index 5359f68cd55..4259815328b 100644
--- a/tests/ui/macros/issue-92267.stderr
+++ b/tests/ui/macros/issue-92267.stderr
@@ -12,5 +12,5 @@ LL | pub fn main() { println!("🦀%%%", 0) }
    |                               ^^
    = note: printf formatting is not supported; see the documentation for `std::fmt`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-attribute.stderr b/tests/ui/macros/macro-attribute.stderr
index 3316d387264..bbcaaba66e5 100644
--- a/tests/ui/macros/macro-attribute.stderr
+++ b/tests/ui/macros/macro-attribute.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `$`
 LL | #[doc = $not_there]
    |         ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-backtrace-println.stderr b/tests/ui/macros/macro-backtrace-println.stderr
index b4e2883e837..9e65cc3dcd6 100644
--- a/tests/ui/macros/macro-backtrace-println.stderr
+++ b/tests/ui/macros/macro-backtrace-println.stderr
@@ -9,5 +9,5 @@ LL |     myprintln!("{}");
    |
    = note: this error originates in the macro `concat` which comes from the expansion of the macro `myprintln` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-crate-nonterminal-non-root.stderr b/tests/ui/macros/macro-crate-nonterminal-non-root.stderr
index 1eca0186da9..10b78d6eb39 100644
--- a/tests/ui/macros/macro-crate-nonterminal-non-root.stderr
+++ b/tests/ui/macros/macro-crate-nonterminal-non-root.stderr
@@ -4,6 +4,6 @@ error[E0468]: an `extern crate` loading macros must be at the crate root
 LL |     extern crate macro_crate_nonterminal;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0468`.
diff --git a/tests/ui/macros/macro-in-expression-context-2.stderr b/tests/ui/macros/macro-in-expression-context-2.stderr
index d0312c48508..1813a2ec792 100644
--- a/tests/ui/macros/macro-in-expression-context-2.stderr
+++ b/tests/ui/macros/macro-in-expression-context-2.stderr
@@ -13,5 +13,5 @@ help: add `;` to interpret the expansion as a statement
 LL |         _ => { empty!(); }
    |                        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-in-expression-context.stderr b/tests/ui/macros/macro-in-expression-context.stderr
index 3f492b141a5..2eee63f307a 100644
--- a/tests/ui/macros/macro-in-expression-context.stderr
+++ b/tests/ui/macros/macro-in-expression-context.stderr
@@ -29,7 +29,7 @@ LL |     foo!()
    = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
    = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 Future incompatibility report: Future breakage diagnostic:
 warning: trailing semicolon in macro used in expression position
diff --git a/tests/ui/macros/macro-inner-attributes.stderr b/tests/ui/macros/macro-inner-attributes.stderr
index 77b6486155c..b6e10f45e38 100644
--- a/tests/ui/macros/macro-inner-attributes.stderr
+++ b/tests/ui/macros/macro-inner-attributes.stderr
@@ -9,6 +9,6 @@ help: there is a crate or module with a similar name
 LL |     b::bar();
    |     ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/macros/macro-interpolation.stderr b/tests/ui/macros/macro-interpolation.stderr
index 7ef1fcbbce3..e6b39dfef85 100644
--- a/tests/ui/macros/macro-interpolation.stderr
+++ b/tests/ui/macros/macro-interpolation.stderr
@@ -12,5 +12,5 @@ LL |     let _: qpath!(ty, <str as !>::Owned);
    |
    = note: this error originates in the macro `qpath` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-invalid-fragment-spec.stderr b/tests/ui/macros/macro-invalid-fragment-spec.stderr
index b0473448265..919111ede51 100644
--- a/tests/ui/macros/macro-invalid-fragment-spec.stderr
+++ b/tests/ui/macros/macro-invalid-fragment-spec.stderr
@@ -6,5 +6,5 @@ LL |     ($x:foo) => ()
    |
    = help: valid fragment specifiers are `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, `path`, `meta`, `tt`, `item` and `vis`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-local-data-key-priv.stderr b/tests/ui/macros/macro-local-data-key-priv.stderr
index 0f412bc86fb..e93bd11046d 100644
--- a/tests/ui/macros/macro-local-data-key-priv.stderr
+++ b/tests/ui/macros/macro-local-data-key-priv.stderr
@@ -11,6 +11,6 @@ LL |     thread_local!(static baz: f64 = 0.0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/macros/macro-missing-delimiters.stderr b/tests/ui/macros/macro-missing-delimiters.stderr
index e7c37c8ddbe..1fe714aa7aa 100644
--- a/tests/ui/macros/macro-missing-delimiters.stderr
+++ b/tests/ui/macros/macro-missing-delimiters.stderr
@@ -4,5 +4,5 @@ error: invalid macro matcher; matchers must be contained in balanced delimiters
 LL |     baz => ()
    |     ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-missing-fragment.stderr b/tests/ui/macros/macro-missing-fragment.stderr
index 2aa1e58f6b1..1089f67f433 100644
--- a/tests/ui/macros/macro-missing-fragment.stderr
+++ b/tests/ui/macros/macro-missing-fragment.stderr
@@ -36,5 +36,5 @@ LL |     ( $name ) => {};
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #40107 <https://github.com/rust-lang/rust/issues/40107>
 
-error: aborting due to previous error; 3 warnings emitted
+error: aborting due to 1 previous error; 3 warnings emitted
 
diff --git a/tests/ui/macros/macro-name-typo.stderr b/tests/ui/macros/macro-name-typo.stderr
index d7c8aaae22e..9059b10faaa 100644
--- a/tests/ui/macros/macro-name-typo.stderr
+++ b/tests/ui/macros/macro-name-typo.stderr
@@ -7,5 +7,5 @@ LL |     printlx!("oh noes!");
    |
    = note: similarly named macro `println` defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-non-lifetime.stderr b/tests/ui/macros/macro-non-lifetime.stderr
index e1ed87f9435..9ff3d741c01 100644
--- a/tests/ui/macros/macro-non-lifetime.stderr
+++ b/tests/ui/macros/macro-non-lifetime.stderr
@@ -13,5 +13,5 @@ note: while trying to match meta-variable `$x:lifetime`
 LL | macro_rules! m { ($x:lifetime) => { } }
    |                   ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-outer-attributes.stderr b/tests/ui/macros/macro-outer-attributes.stderr
index 0418e611604..87c0655a422 100644
--- a/tests/ui/macros/macro-outer-attributes.stderr
+++ b/tests/ui/macros/macro-outer-attributes.stderr
@@ -19,6 +19,6 @@ LL -     a::bar();
 LL +     bar();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/macros/macro-parameter-span.stderr b/tests/ui/macros/macro-parameter-span.stderr
index 24e3e89ea9b..247750a8ad7 100644
--- a/tests/ui/macros/macro-parameter-span.stderr
+++ b/tests/ui/macros/macro-parameter-span.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `x` in this scope
 LL |         x
    |         ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/macros/macro-path-prelude-fail-2.stderr b/tests/ui/macros/macro-path-prelude-fail-2.stderr
index 9574b7a1e25..87646031cdb 100644
--- a/tests/ui/macros/macro-path-prelude-fail-2.stderr
+++ b/tests/ui/macros/macro-path-prelude-fail-2.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: partially resolved path in a macro
 LL |         Result::Ok!();
    |         ^^^^^^^^^^ partially resolved path in a macro
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/macros/macro-path-prelude-fail-3.stderr b/tests/ui/macros/macro-path-prelude-fail-3.stderr
index f1c3512bc9b..485d7b7869a 100644
--- a/tests/ui/macros/macro-path-prelude-fail-3.stderr
+++ b/tests/ui/macros/macro-path-prelude-fail-3.stderr
@@ -9,5 +9,5 @@ LL |     inline!();
    |
    = note: `inline` is in scope, but it is an attribute: `#[inline]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-path-prelude-fail-4.stderr b/tests/ui/macros/macro-path-prelude-fail-4.stderr
index 81c6722b56a..642d9e84874 100644
--- a/tests/ui/macros/macro-path-prelude-fail-4.stderr
+++ b/tests/ui/macros/macro-path-prelude-fail-4.stderr
@@ -12,5 +12,5 @@ LL | #[derive(inline)]
    = help: add as non-Derive macro
            `#[inline]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro-path-prelude-shadowing.stderr b/tests/ui/macros/macro-path-prelude-shadowing.stderr
index 4a864c2e927..e719c397ff2 100644
--- a/tests/ui/macros/macro-path-prelude-shadowing.stderr
+++ b/tests/ui/macros/macro-path-prelude-shadowing.stderr
@@ -14,6 +14,6 @@ LL |     use m2::*; // glob-import user-defined `std`
    = help: consider adding an explicit import of `std` to disambiguate
    = help: or use `self::std` to refer to this module unambiguously
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/macros/macro-use-bad-args-1.stderr b/tests/ui/macros/macro-use-bad-args-1.stderr
index 4e5482a518c..6d2f159a574 100644
--- a/tests/ui/macros/macro-use-bad-args-1.stderr
+++ b/tests/ui/macros/macro-use-bad-args-1.stderr
@@ -4,6 +4,6 @@ error[E0466]: bad macro import
 LL | #[macro_use(foo(bar))]
    |             ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0466`.
diff --git a/tests/ui/macros/macro-use-bad-args-2.stderr b/tests/ui/macros/macro-use-bad-args-2.stderr
index c958104eac4..364f3da6e15 100644
--- a/tests/ui/macros/macro-use-bad-args-2.stderr
+++ b/tests/ui/macros/macro-use-bad-args-2.stderr
@@ -4,6 +4,6 @@ error[E0466]: bad macro import
 LL | #[macro_use(foo="bar")]
    |             ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0466`.
diff --git a/tests/ui/macros/macro-use-undef.stderr b/tests/ui/macros/macro-use-undef.stderr
index 85b86e2211f..adbf5274e68 100644
--- a/tests/ui/macros/macro-use-undef.stderr
+++ b/tests/ui/macros/macro-use-undef.stderr
@@ -4,6 +4,6 @@ error[E0469]: imported macro not found
 LL | #[macro_use(macro_two, no_way)]
    |                        ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0469`.
diff --git a/tests/ui/macros/macro-use-wrong-name.stderr b/tests/ui/macros/macro-use-wrong-name.stderr
index 36339542ac6..89345866be8 100644
--- a/tests/ui/macros/macro-use-wrong-name.stderr
+++ b/tests/ui/macros/macro-use-wrong-name.stderr
@@ -18,5 +18,5 @@ help: consider importing this macro
 LL + use two_macros::macro_two;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/macro_path_as_generic_bound.stderr b/tests/ui/macros/macro_path_as_generic_bound.stderr
index 00d954d24f3..e25ff57e57f 100644
--- a/tests/ui/macros/macro_path_as_generic_bound.stderr
+++ b/tests/ui/macros/macro_path_as_generic_bound.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `m`
 LL | foo!(m::m2::A);
    |      ^ use of undeclared crate or module `m`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/macros/macro_undefined.stderr b/tests/ui/macros/macro_undefined.stderr
index 4ab16bd1017..cc3efacbc54 100644
--- a/tests/ui/macros/macro_undefined.stderr
+++ b/tests/ui/macros/macro_undefined.stderr
@@ -7,5 +7,5 @@ LL |     macro_rules! kl {
 LL |     k!();
    |     ^ help: a macro with a similar name exists: `kl`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/malformed_macro_lhs.stderr b/tests/ui/macros/malformed_macro_lhs.stderr
index adf64b08935..0c8c4850bfa 100644
--- a/tests/ui/macros/malformed_macro_lhs.stderr
+++ b/tests/ui/macros/malformed_macro_lhs.stderr
@@ -4,5 +4,5 @@ error: invalid macro matcher; matchers must be contained in balanced delimiters
 LL |     t => (1);
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/meta-variable-depth-outside-repeat.stderr b/tests/ui/macros/meta-variable-depth-outside-repeat.stderr
index fad150cadfc..49b5053a023 100644
--- a/tests/ui/macros/meta-variable-depth-outside-repeat.stderr
+++ b/tests/ui/macros/meta-variable-depth-outside-repeat.stderr
@@ -4,5 +4,5 @@ error: meta-variable expression `length` with depth parameter must be called ins
 LL |         ${length(0)}
    |          ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/nonterminal-matching.stderr b/tests/ui/macros/nonterminal-matching.stderr
index 88c2c1c773d..499f9a7637d 100644
--- a/tests/ui/macros/nonterminal-matching.stderr
+++ b/tests/ui/macros/nonterminal-matching.stderr
@@ -25,5 +25,5 @@ LL | complex_nonterminal!(enum E {});
    = help: try using `:tt` instead in the macro definition
    = note: this error originates in the macro `complex_nonterminal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/not-utf8.stderr b/tests/ui/macros/not-utf8.stderr
index 7e1f2dcad11..bf4704285c0 100644
--- a/tests/ui/macros/not-utf8.stderr
+++ b/tests/ui/macros/not-utf8.stderr
@@ -6,5 +6,5 @@ LL |     include!("not-utf8.bin")
    |
    = note: this error originates in the macro `include` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/out-of-order-shadowing.stderr b/tests/ui/macros/out-of-order-shadowing.stderr
index dedefac5c46..8795f7d4345 100644
--- a/tests/ui/macros/out-of-order-shadowing.stderr
+++ b/tests/ui/macros/out-of-order-shadowing.stderr
@@ -17,6 +17,6 @@ LL | macro_rules! bar { () => {} }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `define_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/macros/recovery-allowed.stderr b/tests/ui/macros/recovery-allowed.stderr
index ec036e8b1e2..44689853dab 100644
--- a/tests/ui/macros/recovery-allowed.stderr
+++ b/tests/ui/macros/recovery-allowed.stderr
@@ -6,5 +6,5 @@ LL | please_recover! { not 1 }
    |                   |
    |                   help: use `!` to perform bitwise not
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/span-covering-argument-1.stderr b/tests/ui/macros/span-covering-argument-1.stderr
index e57347b362d..9ad2bc73a4f 100644
--- a/tests/ui/macros/span-covering-argument-1.stderr
+++ b/tests/ui/macros/span-covering-argument-1.stderr
@@ -13,6 +13,6 @@ help: consider changing this to be mutable
 LL |             let mut $s = 0;
    |                 +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/macros/unreachable-arg.edition_2021.stderr b/tests/ui/macros/unreachable-arg.edition_2021.stderr
index d70ef31eed6..ddaa2b9c1ef 100644
--- a/tests/ui/macros/unreachable-arg.edition_2021.stderr
+++ b/tests/ui/macros/unreachable-arg.edition_2021.stderr
@@ -9,5 +9,5 @@ help: you might be missing a string literal to format with
 LL |     unreachable!("{}", a);
    |                  +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/unreachable-format-args.edition_2015.stderr b/tests/ui/macros/unreachable-format-args.edition_2015.stderr
index 2cc2e134bfd..6a133d5e406 100644
--- a/tests/ui/macros/unreachable-format-args.edition_2015.stderr
+++ b/tests/ui/macros/unreachable-format-args.edition_2015.stderr
@@ -8,5 +8,5 @@ LL |     unreachable!("x is {x} and y is {y}", y = 0);
    = note: to avoid ambiguity, `format_args!` cannot capture variables when the format string is expanded from a macro
    = note: this error originates in the macro `$crate::concat` which comes from the expansion of the macro `unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/macros/vec-macro-in-pattern.stderr b/tests/ui/macros/vec-macro-in-pattern.stderr
index 7060f5d8b47..447f5dcf864 100644
--- a/tests/ui/macros/vec-macro-in-pattern.stderr
+++ b/tests/ui/macros/vec-macro-in-pattern.stderr
@@ -6,5 +6,5 @@ LL |         Some(vec![43]) => {}
    |
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/main-wrong-location.stderr b/tests/ui/main-wrong-location.stderr
index 3d64b0a67a1..9486a940562 100644
--- a/tests/ui/main-wrong-location.stderr
+++ b/tests/ui/main-wrong-location.stderr
@@ -12,6 +12,6 @@ LL |     fn main() { }
    = note: you have one or more functions named `main` not defined at the crate level
    = help: consider moving the `main` function definitions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/main-wrong-type.stderr b/tests/ui/main-wrong-type.stderr
index 1e5f368758e..d07fc09064f 100644
--- a/tests/ui/main-wrong-type.stderr
+++ b/tests/ui/main-wrong-type.stderr
@@ -7,6 +7,6 @@ LL | fn main(foo: S) {
    = note: expected signature `fn()`
               found signature `fn(S)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0580`.
diff --git a/tests/ui/malformed/issue-107423-unused-delim-only-one-no-pair.stderr b/tests/ui/malformed/issue-107423-unused-delim-only-one-no-pair.stderr
index 89e0d982eaf..ad90aeda1d1 100644
--- a/tests/ui/malformed/issue-107423-unused-delim-only-one-no-pair.stderr
+++ b/tests/ui/malformed/issue-107423-unused-delim-only-one-no-pair.stderr
@@ -8,5 +8,5 @@ LL | fn a(){{{
    |       |unclosed delimiter
    |       unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/malformed/issue-69341-malformed-derive-inert.stderr b/tests/ui/malformed/issue-69341-malformed-derive-inert.stderr
index 04f7ebe019e..99f709eadb7 100644
--- a/tests/ui/malformed/issue-69341-malformed-derive-inert.stderr
+++ b/tests/ui/malformed/issue-69341-malformed-derive-inert.stderr
@@ -4,5 +4,5 @@ error: expected non-macro attribute, found attribute macro `derive`
 LL |     #[derive(parse())]
    |       ^^^^^^ not a non-macro attribute
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/manual/manual-link-framework.stderr b/tests/ui/manual/manual-link-framework.stderr
index de045d56c9c..38d2302a48d 100644
--- a/tests/ui/manual/manual-link-framework.stderr
+++ b/tests/ui/manual/manual-link-framework.stderr
@@ -1,4 +1,4 @@
 error: library kind `framework` is only supported on Apple targets
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/marker_trait_attr/overlap-marker-trait.stderr b/tests/ui/marker_trait_attr/overlap-marker-trait.stderr
index 133bc0484ee..cdad382d11c 100644
--- a/tests/ui/marker_trait_attr/overlap-marker-trait.stderr
+++ b/tests/ui/marker_trait_attr/overlap-marker-trait.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `is_marker`
 LL | fn is_marker<T: Marker>() { }
    |                 ^^^^^^ required by this bound in `is_marker`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr b/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
index 64bccda56c6..daee4e66ad1 100644
--- a/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
+++ b/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | impl<T: Copy + 'static> F for T {}
    |              +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/marker_trait_attr/unsound-overlap.stderr b/tests/ui/marker_trait_attr/unsound-overlap.stderr
index 5ebac8270dd..5e58f5227ed 100644
--- a/tests/ui/marker_trait_attr/unsound-overlap.stderr
+++ b/tests/ui/marker_trait_attr/unsound-overlap.stderr
@@ -7,6 +7,6 @@ LL | impl<T: A> TraitWithAssoc for T {
 LL | impl TraitWithAssoc for ((&str,),) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `((&str,),)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/match/issue-11319.stderr b/tests/ui/match/issue-11319.stderr
index fc44205e81e..8280547af43 100644
--- a/tests/ui/match/issue-11319.stderr
+++ b/tests/ui/match/issue-11319.stderr
@@ -16,6 +16,6 @@ LL | |         _       => true
 LL | |     }
    | |_____- `match` arms have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/issue-70972-dyn-trait.stderr b/tests/ui/match/issue-70972-dyn-trait.stderr
index f4dc910c34a..b0af50f8599 100644
--- a/tests/ui/match/issue-70972-dyn-trait.stderr
+++ b/tests/ui/match/issue-70972-dyn-trait.stderr
@@ -4,5 +4,5 @@ error: `dyn Send` cannot be used in patterns
 LL |         F => panic!(),
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/match/issue-74050-end-span.stderr b/tests/ui/match/issue-74050-end-span.stderr
index 0dafeae870e..3a311eb00cc 100644
--- a/tests/ui/match/issue-74050-end-span.stderr
+++ b/tests/ui/match/issue-74050-end-span.stderr
@@ -11,6 +11,6 @@ LL |             match arg.to_str() {
 LL |         }
    |         - `arg` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/match/issue-91058.stderr b/tests/ui/match/issue-91058.stderr
index 12f37274b6b..e91063de8e0 100644
--- a/tests/ui/match/issue-91058.stderr
+++ b/tests/ui/match/issue-91058.stderr
@@ -6,6 +6,6 @@ LL |     match array {
 LL |         [()] => {}
    |          ^^ expected `S`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/issue-92100.stderr b/tests/ui/match/issue-92100.stderr
index d0e50f3ae16..eb9f4ba1ad6 100644
--- a/tests/ui/match/issue-92100.stderr
+++ b/tests/ui/match/issue-92100.stderr
@@ -9,6 +9,6 @@ help: if you meant to collect the rest of the slice in `a`, use the at operator
 LL |         [a @ .., a] => {}
    |            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/match/match-arm-resolving-to-never.stderr b/tests/ui/match/match-arm-resolving-to-never.stderr
index 686fbd0baa3..6cbdf03d4c2 100644
--- a/tests/ui/match/match-arm-resolving-to-never.stderr
+++ b/tests/ui/match/match-arm-resolving-to-never.stderr
@@ -13,6 +13,6 @@ LL | |         E::F => "",
 LL | |     };
    | |_____- `match` arms have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/match-ill-type2.stderr b/tests/ui/match/match-ill-type2.stderr
index 5078f03d601..9d6bb5d1dcd 100644
--- a/tests/ui/match/match-ill-type2.stderr
+++ b/tests/ui/match/match-ill-type2.stderr
@@ -7,6 +7,6 @@ LL |         1i32 => 1,
 LL |         2u32 => 1,
    |         ^^^^ expected `i32`, found `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/match-join.stderr b/tests/ui/match/match-join.stderr
index 27a82c1242c..4feb1bef9ad 100644
--- a/tests/ui/match/match-join.stderr
+++ b/tests/ui/match/match-join.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `x` in this scope
 LL |     println!("{}", x);
    |                    ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/match/match-no-arms-unreachable-after.stderr b/tests/ui/match/match-no-arms-unreachable-after.stderr
index a0a3697266d..65ac1bae344 100644
--- a/tests/ui/match/match-no-arms-unreachable-after.stderr
+++ b/tests/ui/match/match-no-arms-unreachable-after.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/match/match-pattern-field-mismatch-2.stderr b/tests/ui/match/match-pattern-field-mismatch-2.stderr
index ba32d0e99a4..12b143dd29b 100644
--- a/tests/ui/match/match-pattern-field-mismatch-2.stderr
+++ b/tests/ui/match/match-pattern-field-mismatch-2.stderr
@@ -7,6 +7,6 @@ LL |         NoColor,
 LL |           Color::NoColor(_) => { }
    |           ^^^^^^^^^^^^^^^^^ help: use this syntax instead: `Color::NoColor`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/match/match-pattern-field-mismatch.stderr b/tests/ui/match/match-pattern-field-mismatch.stderr
index c994ee4f6d4..cde7ac972ca 100644
--- a/tests/ui/match/match-pattern-field-mismatch.stderr
+++ b/tests/ui/match/match-pattern-field-mismatch.stderr
@@ -16,6 +16,6 @@ help: use `..` to ignore all fields
 LL |           Color::Rgb(..) => { }
    |                      ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0023`.
diff --git a/tests/ui/match/match-ref-mut-invariance.stderr b/tests/ui/match/match-ref-mut-invariance.stderr
index b353d3514fe..b9878a19532 100644
--- a/tests/ui/match/match-ref-mut-invariance.stderr
+++ b/tests/ui/match/match-ref-mut-invariance.stderr
@@ -13,5 +13,5 @@ LL |         match self.0 { ref mut x => x }
    = note: mutable references are invariant over their type parameter
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/match/match-ref-mut-let-invariance.stderr b/tests/ui/match/match-ref-mut-let-invariance.stderr
index bb0fcdb9990..27968239a8e 100644
--- a/tests/ui/match/match-ref-mut-let-invariance.stderr
+++ b/tests/ui/match/match-ref-mut-let-invariance.stderr
@@ -14,5 +14,5 @@ LL |         x
    = note: mutable references are invariant over their type parameter
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/match/match-struct.stderr b/tests/ui/match/match-struct.stderr
index fdc6fd77077..b8abeab158b 100644
--- a/tests/ui/match/match-struct.stderr
+++ b/tests/ui/match/match-struct.stderr
@@ -6,6 +6,6 @@ LL |     match (S { a: 1 }) {
 LL |         E::C(_) => (),
    |         ^^^^^^^ expected `S`, found `E`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/match-tag-nullary.stderr b/tests/ui/match/match-tag-nullary.stderr
index aac873c760e..c9446d16433 100644
--- a/tests/ui/match/match-tag-nullary.stderr
+++ b/tests/ui/match/match-tag-nullary.stderr
@@ -9,6 +9,6 @@ LL | fn main() { let x: A = A::A; match x { B::B => { } } }
    |                                    |
    |                                    this expression has type `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/match-tag-unary.stderr b/tests/ui/match/match-tag-unary.stderr
index 25e8152d8cf..fb4ec266461 100644
--- a/tests/ui/match/match-tag-unary.stderr
+++ b/tests/ui/match/match-tag-unary.stderr
@@ -6,6 +6,6 @@ LL | fn main() { let x: A = A::A(0); match x { B::B(y) => { } } }
    |                                       |
    |                                       this expression has type `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/match-unresolved-one-arm.stderr b/tests/ui/match/match-unresolved-one-arm.stderr
index e3b501b2fd5..44571ac5326 100644
--- a/tests/ui/match/match-unresolved-one-arm.stderr
+++ b/tests/ui/match/match-unresolved-one-arm.stderr
@@ -9,6 +9,6 @@ help: consider giving `x` an explicit type
 LL |     let x: /* Type */ = match () {
    |          ++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/match/match-vec-mismatch-2.stderr b/tests/ui/match/match-vec-mismatch-2.stderr
index 5247bea62ce..bdfe063d5bb 100644
--- a/tests/ui/match/match-vec-mismatch-2.stderr
+++ b/tests/ui/match/match-vec-mismatch-2.stderr
@@ -4,6 +4,6 @@ error[E0529]: expected an array or slice, found `()`
 LL |         [()] => { }
    |         ^^^^ pattern cannot match with input type `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0529`.
diff --git a/tests/ui/match/non-first-arm-doesnt-match-expected-return-type.stderr b/tests/ui/match/non-first-arm-doesnt-match-expected-return-type.stderr
index e6d93b8b5f5..5a6c9dff757 100644
--- a/tests/ui/match/non-first-arm-doesnt-match-expected-return-type.stderr
+++ b/tests/ui/match/non-first-arm-doesnt-match-expected-return-type.stderr
@@ -7,6 +7,6 @@ LL | fn test(shouldwe: Option<u32>, shouldwe2: Option<u32>) -> u32 {
 LL |                 None => (),
    |                         ^^ expected `u32`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/match/single-line.stderr b/tests/ui/match/single-line.stderr
index ec3b76e3f4d..15dc672c1fd 100644
--- a/tests/ui/match/single-line.stderr
+++ b/tests/ui/match/single-line.stderr
@@ -7,6 +7,6 @@ LL |     let _ = match Some(42) { Some(x) => x, None => "" };
    |             |                           this is found to be of type `{integer}`
    |             `match` arms have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/meta/expected-error-correct-rev.a.stderr b/tests/ui/meta/expected-error-correct-rev.a.stderr
index 4adeebe2a59..d5b7603d346 100644
--- a/tests/ui/meta/expected-error-correct-rev.a.stderr
+++ b/tests/ui/meta/expected-error-correct-rev.a.stderr
@@ -11,6 +11,6 @@ help: change the type of the numeric literal from `usize` to `u32`
 LL |     let x: u32 = 22_u32;
    |                     ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr b/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr
index 87330155eac..4221dd04cfa 100644
--- a/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr
+++ b/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr
@@ -11,6 +11,6 @@ help: change the type of the numeric literal from `usize` to `u32`
 LL |     let x: u32 = 22_u32;
    |                     ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/methods/issue-3707.stderr b/tests/ui/methods/issue-3707.stderr
index 07c8101cbc6..b3d4dfe5aaa 100644
--- a/tests/ui/methods/issue-3707.stderr
+++ b/tests/ui/methods/issue-3707.stderr
@@ -14,6 +14,6 @@ note: the candidate is defined in an impl for the type `Obj`
 LL |     pub fn boom() -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/methods/issues/issue-84495.stderr b/tests/ui/methods/issues/issue-84495.stderr
index b0217a7c844..1603c0026be 100644
--- a/tests/ui/methods/issues/issue-84495.stderr
+++ b/tests/ui/methods/issues/issue-84495.stderr
@@ -8,6 +8,6 @@ LL |     println!("{:?}", x.count());
            `i32: Iterator`
            which is required by `&mut i32: Iterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/methods/issues/issue-94581.stderr b/tests/ui/methods/issues/issue-94581.stderr
index d6be29cf582..ae7446d4833 100644
--- a/tests/ui/methods/issues/issue-94581.stderr
+++ b/tests/ui/methods/issues/issue-94581.stderr
@@ -10,6 +10,6 @@ LL |     let sqsum = get_slice().map(|i| i * i).sum();
            `[i32]: Iterator`
            which is required by `&mut [i32]: Iterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/methods/method-ambig-two-traits-cross-crate.stderr b/tests/ui/methods/method-ambig-two-traits-cross-crate.stderr
index 5132d92777b..0c775612bfb 100644
--- a/tests/ui/methods/method-ambig-two-traits-cross-crate.stderr
+++ b/tests/ui/methods/method-ambig-two-traits-cross-crate.stderr
@@ -19,6 +19,6 @@ help: disambiguate the method for candidate #2
 LL | fn main() { Me2::me(&1_usize); }
    |             ~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/methods/method-ambig-two-traits-from-bounds.stderr b/tests/ui/methods/method-ambig-two-traits-from-bounds.stderr
index 9a84768a9f4..690f979fa37 100644
--- a/tests/ui/methods/method-ambig-two-traits-from-bounds.stderr
+++ b/tests/ui/methods/method-ambig-two-traits-from-bounds.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |     B::foo(&t);
    |     ~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/methods/method-ambig-two-traits-from-impls.stderr b/tests/ui/methods/method-ambig-two-traits-from-impls.stderr
index 31359143391..8be6d6d64f7 100644
--- a/tests/ui/methods/method-ambig-two-traits-from-impls.stderr
+++ b/tests/ui/methods/method-ambig-two-traits-from-impls.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |     B::foo(AB {});
    |     ~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/methods/method-ambig-two-traits-from-impls2.stderr b/tests/ui/methods/method-ambig-two-traits-from-impls2.stderr
index 5bb887b4503..333520847f8 100644
--- a/tests/ui/methods/method-ambig-two-traits-from-impls2.stderr
+++ b/tests/ui/methods/method-ambig-two-traits-from-impls2.stderr
@@ -21,6 +21,6 @@ LL |     <AB as A>::foo();
 LL |     <AB as B>::foo();
    |     ~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/methods/method-ambig-two-traits-with-default-method.stderr b/tests/ui/methods/method-ambig-two-traits-with-default-method.stderr
index df01966b3a2..9da307436e9 100644
--- a/tests/ui/methods/method-ambig-two-traits-with-default-method.stderr
+++ b/tests/ui/methods/method-ambig-two-traits-with-default-method.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |     Bar::method(&1_usize);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/methods/method-ambiguity-no-rcvr.stderr b/tests/ui/methods/method-ambiguity-no-rcvr.stderr
index 95c9d7ebac0..73f6043f256 100644
--- a/tests/ui/methods/method-ambiguity-no-rcvr.stderr
+++ b/tests/ui/methods/method-ambiguity-no-rcvr.stderr
@@ -27,6 +27,6 @@ help: disambiguate the associated function for candidate #2
 LL |     <Qux as FooBar>::foo(Qux);
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/methods/method-call-lifetime-args-unresolved.stderr b/tests/ui/methods/method-call-lifetime-args-unresolved.stderr
index 25ad360b329..c72e7e0cdc3 100644
--- a/tests/ui/methods/method-call-lifetime-args-unresolved.stderr
+++ b/tests/ui/methods/method-call-lifetime-args-unresolved.stderr
@@ -19,6 +19,6 @@ LL |     0.clone::<'a>();
    = note: for more information, see issue #42868 <https://github.com/rust-lang/rust/issues/42868>
    = note: `#[warn(late_bound_lifetime_arguments)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0261`.
diff --git a/tests/ui/methods/method-call-type-binding.stderr b/tests/ui/methods/method-call-type-binding.stderr
index 4b93082ace5..54d855d340e 100644
--- a/tests/ui/methods/method-call-type-binding.stderr
+++ b/tests/ui/methods/method-call-type-binding.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     0.clone::<T = u8>();
    |               ^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/ui/methods/method-macro-backtrace.stderr b/tests/ui/methods/method-macro-backtrace.stderr
index dd616c4a5e7..f0b11137989 100644
--- a/tests/ui/methods/method-macro-backtrace.stderr
+++ b/tests/ui/methods/method-macro-backtrace.stderr
@@ -6,6 +6,6 @@ LL |     fn bar(&self) { }
 LL |     fn bar(&self) { }
    |     ^^^^^^^^^^^^^ duplicate definitions for `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/methods/method-not-found-but-doc-alias.stderr b/tests/ui/methods/method-not-found-but-doc-alias.stderr
index 5102a452f0c..9746c404013 100644
--- a/tests/ui/methods/method-not-found-but-doc-alias.stderr
+++ b/tests/ui/methods/method-not-found-but-doc-alias.stderr
@@ -7,6 +7,6 @@ LL | struct Foo;
 LL |     Foo.quux();
    |         ^^^^ help: there is a method with a similar name: `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/methods/method-resolvable-path-in-pattern.stderr b/tests/ui/methods/method-resolvable-path-in-pattern.stderr
index 7c454a9a777..070d912d129 100644
--- a/tests/ui/methods/method-resolvable-path-in-pattern.stderr
+++ b/tests/ui/methods/method-resolvable-path-in-pattern.stderr
@@ -4,6 +4,6 @@ error[E0532]: expected unit struct, unit variant or constant, found associated f
 LL |         <Foo as MyTrait>::trait_bar => {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a unit struct, unit variant or constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/methods/suggest-method-on-call-with-macro-rcvr.stderr b/tests/ui/methods/suggest-method-on-call-with-macro-rcvr.stderr
index 9694f80ab6d..86c2f6431d1 100644
--- a/tests/ui/methods/suggest-method-on-call-with-macro-rcvr.stderr
+++ b/tests/ui/methods/suggest-method-on-call-with-macro-rcvr.stderr
@@ -10,6 +10,6 @@ LL -     let hello = len(vec![]);
 LL +     let hello = vec![].len();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/minus-string.stderr b/tests/ui/minus-string.stderr
index b429ad3046e..105274ee7d0 100644
--- a/tests/ui/minus-string.stderr
+++ b/tests/ui/minus-string.stderr
@@ -4,6 +4,6 @@ error[E0600]: cannot apply unary operator `-` to type `String`
 LL | fn main() { -"foo".to_string(); }
    |             ^^^^^^^^^^^^^^^^^^ cannot apply unary operator `-`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/mir/build-async-error-body-correctly.stderr b/tests/ui/mir/build-async-error-body-correctly.stderr
index 3d18c249afe..4b9cdc4f937 100644
--- a/tests/ui/mir/build-async-error-body-correctly.stderr
+++ b/tests/ui/mir/build-async-error-body-correctly.stderr
@@ -12,6 +12,6 @@ LL +         _ => todo!(),
 LL ~     };
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/mir/field-projection-mutating-context.stderr b/tests/ui/mir/field-projection-mutating-context.stderr
index 9b18b3427ad..62c9e55a44b 100644
--- a/tests/ui/mir/field-projection-mutating-context.stderr
+++ b/tests/ui/mir/field-projection-mutating-context.stderr
@@ -7,6 +7,6 @@ LL |     let Foo(ref mut y): Foo<fn(&'static str)> = x;
    = note: expected fn pointer `for<'a> fn(&'a str)`
               found fn pointer `fn(&str)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mir/field-projection-mutating-context2.stderr b/tests/ui/mir/field-projection-mutating-context2.stderr
index a7b66fe10ce..16740017041 100644
--- a/tests/ui/mir/field-projection-mutating-context2.stderr
+++ b/tests/ui/mir/field-projection-mutating-context2.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a>(mut x: Foo<fn(&'a str)>, string: &'a str) {
 LL |     let Foo(ref mut y): Foo<fn(&'static str)> = x;
    |                         ^^^^^^^^^^^^^^^^^^^^^ type annotation requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/mir/issue-102389.stderr b/tests/ui/mir/issue-102389.stderr
index 925dc258a4c..1f04d119b56 100644
--- a/tests/ui/mir/issue-102389.stderr
+++ b/tests/ui/mir/issue-102389.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of `*inbounds` which is behind a shared reference
 LL |     array[*inbounds as usize]
    |           ^^^^^^^^^ move occurs because `*inbounds` has type `Enum`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/mir/issue-106062.stderr b/tests/ui/mir/issue-106062.stderr
index 2f6524d03e0..30635148dae 100644
--- a/tests/ui/mir/issue-106062.stderr
+++ b/tests/ui/mir/issue-106062.stderr
@@ -11,6 +11,6 @@ LL |     async fn connection_handler(handler: impl Sized) -> Result<core::result
 LL |     async fn connection_handler(handler: impl Sized) -> Result<std::result::Result, std::io::Error> {
    |                                                                ~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0573`.
diff --git a/tests/ui/mir/issue-75053.stderr b/tests/ui/mir/issue-75053.stderr
index 64e59e6c448..bd37f0c92ad 100644
--- a/tests/ui/mir/issue-75053.stderr
+++ b/tests/ui/mir/issue-75053.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/mir/issue-92893.stderr b/tests/ui/mir/issue-92893.stderr
index 6c1a9dc0317..3bf056d152c 100644
--- a/tests/ui/mir/issue-92893.stderr
+++ b/tests/ui/mir/issue-92893.stderr
@@ -6,5 +6,5 @@ LL | struct Bug<A = [(); (let a = (), 1).1]> {
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/mismatched_types/assignment-operator-unimplemented.stderr b/tests/ui/mismatched_types/assignment-operator-unimplemented.stderr
index 66a85c4656a..6609fa8c071 100644
--- a/tests/ui/mismatched_types/assignment-operator-unimplemented.stderr
+++ b/tests/ui/mismatched_types/assignment-operator-unimplemented.stderr
@@ -14,6 +14,6 @@ LL | struct Foo;
 note: the trait `AddAssign` must be implemented
   --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0368`.
diff --git a/tests/ui/mismatched_types/closure-arg-count-expected-type-issue-47244.stderr b/tests/ui/mismatched_types/closure-arg-count-expected-type-issue-47244.stderr
index d7db90e50e5..801e8a0ff1d 100644
--- a/tests/ui/mismatched_types/closure-arg-count-expected-type-issue-47244.stderr
+++ b/tests/ui/mismatched_types/closure-arg-count-expected-type-issue-47244.stderr
@@ -11,6 +11,6 @@ help: change the closure to accept a tuple instead of individual arguments
 LL |     let _n = m.iter().map(|(_, b)| {
    |                           ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0593`.
diff --git a/tests/ui/mismatched_types/closure-ref-114180.stderr b/tests/ui/mismatched_types/closure-ref-114180.stderr
index 8a146d784e2..798c4e00aa7 100644
--- a/tests/ui/mismatched_types/closure-ref-114180.stderr
+++ b/tests/ui/mismatched_types/closure-ref-114180.stderr
@@ -17,6 +17,6 @@ help: consider adjusting the signature so it borrows its arguments
 LL |     let compare = |&(a,), &(e,)| todo!();
    |                    +      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/mismatched_types/dont-point-return-on-E0308.stderr b/tests/ui/mismatched_types/dont-point-return-on-E0308.stderr
index 7be94ef4ad6..9d4852cff8c 100644
--- a/tests/ui/mismatched_types/dont-point-return-on-E0308.stderr
+++ b/tests/ui/mismatched_types/dont-point-return-on-E0308.stderr
@@ -16,6 +16,6 @@ help: consider borrowing here
 LL |         f(&());
    |           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/for-loop-has-unit-body.stderr b/tests/ui/mismatched_types/for-loop-has-unit-body.stderr
index f36fe64bffb..f7524479018 100644
--- a/tests/ui/mismatched_types/for-loop-has-unit-body.stderr
+++ b/tests/ui/mismatched_types/for-loop-has-unit-body.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |         x
    |         ^ expected `()`, found integer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/issue-106182.stderr b/tests/ui/mismatched_types/issue-106182.stderr
index 96ab3a02991..2f33628a491 100644
--- a/tests/ui/mismatched_types/issue-106182.stderr
+++ b/tests/ui/mismatched_types/issue-106182.stderr
@@ -13,6 +13,6 @@ help: consider removing `&` from the pattern
 LL |         _S(mut _y, _v) => {
    |            ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/issue-112036.stderr b/tests/ui/mismatched_types/issue-112036.stderr
index a883aba35bf..b93ce4a8674 100644
--- a/tests/ui/mismatched_types/issue-112036.stderr
+++ b/tests/ui/mismatched_types/issue-112036.stderr
@@ -10,6 +10,6 @@ LL |     fn drop(self) {}
    = note: expected signature `fn(&mut Foo)`
               found signature `fn(Foo)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/mismatched_types/issue-13033.stderr b/tests/ui/mismatched_types/issue-13033.stderr
index db2c1189e1e..4886fa30e89 100644
--- a/tests/ui/mismatched_types/issue-13033.stderr
+++ b/tests/ui/mismatched_types/issue-13033.stderr
@@ -15,6 +15,6 @@ LL |     fn bar(&mut self, other: &mut dyn Foo);
    = note: expected signature `fn(&mut Baz, &mut dyn Foo)`
               found signature `fn(&mut Baz, &dyn Foo)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/mismatched_types/issue-19109.stderr b/tests/ui/mismatched_types/issue-19109.stderr
index ca819d93a50..e769ed0c1f9 100644
--- a/tests/ui/mismatched_types/issue-19109.stderr
+++ b/tests/ui/mismatched_types/issue-19109.stderr
@@ -9,6 +9,6 @@ LL |     t as *mut dyn Trait
    = note: expected unit type `()`
             found raw pointer `*mut dyn Trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/issue-35030.stderr b/tests/ui/mismatched_types/issue-35030.stderr
index 881ff909722..62f83ce706f 100644
--- a/tests/ui/mismatched_types/issue-35030.stderr
+++ b/tests/ui/mismatched_types/issue-35030.stderr
@@ -21,6 +21,6 @@ LL |         Some(true)
 note: tuple variant defined here
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/issue-47706-trait.stderr b/tests/ui/mismatched_types/issue-47706-trait.stderr
index a5f38dd5366..c54a62c5e6f 100644
--- a/tests/ui/mismatched_types/issue-47706-trait.stderr
+++ b/tests/ui/mismatched_types/issue-47706-trait.stderr
@@ -11,6 +11,6 @@ LL |         None::<()>.map(Self::f);
 note: required by a bound in `Option::<T>::map`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0593`.
diff --git a/tests/ui/mismatched_types/issue-75361-mismatched-impl.stderr b/tests/ui/mismatched_types/issue-75361-mismatched-impl.stderr
index 88416ba4bb6..5c2278ddfc6 100644
--- a/tests/ui/mismatched_types/issue-75361-mismatched-impl.stderr
+++ b/tests/ui/mismatched_types/issue-75361-mismatched-impl.stderr
@@ -15,5 +15,5 @@ help: the lifetime requirements from the `impl` do not correspond to the require
 LL |   fn adjacent_edges(&self) -> Box<dyn MyTrait<Item = &Self::EdgeType>>;
    |                                                       ^^^^ consider borrowing this type parameter in the trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/mismatched_types/main.stderr b/tests/ui/mismatched_types/main.stderr
index a662741afcd..38146cef347 100644
--- a/tests/ui/mismatched_types/main.stderr
+++ b/tests/ui/mismatched_types/main.stderr
@@ -8,6 +8,6 @@ LL |       let x: u32 = (
 LL | |     );
    | |_____^ expected `u32`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/method-help-unsatisfied-bound.stderr b/tests/ui/mismatched_types/method-help-unsatisfied-bound.stderr
index 9dab3e52255..be3a3e2abf1 100644
--- a/tests/ui/mismatched_types/method-help-unsatisfied-bound.stderr
+++ b/tests/ui/mismatched_types/method-help-unsatisfied-bound.stderr
@@ -14,6 +14,6 @@ LL + #[derive(Debug)]
 LL | struct Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/mismatched_types/normalize-fn-sig.stderr b/tests/ui/mismatched_types/normalize-fn-sig.stderr
index 252e56387ba..2166de85f1f 100644
--- a/tests/ui/mismatched_types/normalize-fn-sig.stderr
+++ b/tests/ui/mismatched_types/normalize-fn-sig.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn needs_i32_ref_fn(_: fn(&'static i32, i32)) {}
    |    ^^^^^^^^^^^^^^^^ ------------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/recovered-block.stderr b/tests/ui/mismatched_types/recovered-block.stderr
index 88d62545656..51b5f3b1af2 100644
--- a/tests/ui/mismatched_types/recovered-block.stderr
+++ b/tests/ui/mismatched_types/recovered-block.stderr
@@ -9,5 +9,5 @@ help: add `struct` here to parse `Foo` as a public struct
 LL |     pub struct Foo { text }
    |         ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/mismatched_types/show_module.stderr b/tests/ui/mismatched_types/show_module.stderr
index 4bbeaaab937..e95467add38 100644
--- a/tests/ui/mismatched_types/show_module.stderr
+++ b/tests/ui/mismatched_types/show_module.stderr
@@ -18,6 +18,6 @@ note: `baz::Foo` is defined in module `crate::blah::baz` of the current crate
 LL |         pub struct Foo;
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/similar_paths.stderr b/tests/ui/mismatched_types/similar_paths.stderr
index 3e44fb75929..a7a35ec2774 100644
--- a/tests/ui/mismatched_types/similar_paths.stderr
+++ b/tests/ui/mismatched_types/similar_paths.stderr
@@ -15,6 +15,6 @@ note: `Option<u8>` is defined in the current crate
 LL | enum Option<T> {
    | ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/similar_paths_primitive.stderr b/tests/ui/mismatched_types/similar_paths_primitive.stderr
index 80e78a4e4fa..c9881891319 100644
--- a/tests/ui/mismatched_types/similar_paths_primitive.stderr
+++ b/tests/ui/mismatched_types/similar_paths_primitive.stderr
@@ -19,6 +19,6 @@ note: function defined here
 LL | fn foo(_: bool) {}
    |    ^^^ -------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/suggest-option-asderef-inference-var.stderr b/tests/ui/mismatched_types/suggest-option-asderef-inference-var.stderr
index 5c4c13266d0..3db9803d58f 100644
--- a/tests/ui/mismatched_types/suggest-option-asderef-inference-var.stderr
+++ b/tests/ui/mismatched_types/suggest-option-asderef-inference-var.stderr
@@ -19,6 +19,6 @@ LL - fn deref_int(a: &i32) -> i32 {
 LL + fn deref_int(a: i32) -> i32 {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/mismatched_types/trait-bounds-cant-coerce.stderr b/tests/ui/mismatched_types/trait-bounds-cant-coerce.stderr
index 80aef7fcbe8..aaa3a9f191a 100644
--- a/tests/ui/mismatched_types/trait-bounds-cant-coerce.stderr
+++ b/tests/ui/mismatched_types/trait-bounds-cant-coerce.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn a(_x: Box<dyn Foo + Send>) {
    |    ^ -----------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mismatched_types/unboxed-closures-vtable-mismatch.stderr b/tests/ui/mismatched_types/unboxed-closures-vtable-mismatch.stderr
index 54b22006527..a900a49c710 100644
--- a/tests/ui/mismatched_types/unboxed-closures-vtable-mismatch.stderr
+++ b/tests/ui/mismatched_types/unboxed-closures-vtable-mismatch.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `call_it`
 LL | fn call_it<F: FnMut(isize, isize) -> isize>(y: isize, mut f: F) -> isize {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `call_it`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/missing-trait-bounds/issue-35677.stderr b/tests/ui/missing-trait-bounds/issue-35677.stderr
index 05d3de80d84..f73bff51e7a 100644
--- a/tests/ui/missing-trait-bounds/issue-35677.stderr
+++ b/tests/ui/missing-trait-bounds/issue-35677.stderr
@@ -14,6 +14,6 @@ help: consider restricting the type parameters to satisfy the trait bounds
 LL | fn is_subset<T>(this: &HashSet<T>, other: &HashSet<T>) -> bool where T: Eq, T: Hash {
    |                                                                ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/missing-trait-bounds/issue-69725.stderr b/tests/ui/missing-trait-bounds/issue-69725.stderr
index 980d9dd167d..f483ea849b0 100644
--- a/tests/ui/missing-trait-bounds/issue-69725.stderr
+++ b/tests/ui/missing-trait-bounds/issue-69725.stderr
@@ -17,6 +17,6 @@ help: consider restricting the type parameter to satisfy the trait bound
 LL | fn crash<A>() where A: Clone {
    |               ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr b/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
index cde07550125..b3089cecfbb 100644
--- a/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
+++ b/tests/ui/missing-trait-bounds/missing-trait-bound-for-op.stderr
@@ -11,6 +11,6 @@ help: consider restricting type parameter `T`
 LL | pub fn foo<T: std::cmp::PartialEq>(s: &[T], t: &[T]) {
    |             +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/missing/missing-allocator.stderr b/tests/ui/missing/missing-allocator.stderr
index 0da5651c18c..007c488c9d9 100644
--- a/tests/ui/missing/missing-allocator.stderr
+++ b/tests/ui/missing/missing-allocator.stderr
@@ -1,4 +1,4 @@
 error: no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/missing/missing-comma-in-match.stderr b/tests/ui/missing/missing-comma-in-match.stderr
index fe210f697c4..50f74eeb5ed 100644
--- a/tests/ui/missing/missing-comma-in-match.stderr
+++ b/tests/ui/missing/missing-comma-in-match.stderr
@@ -6,5 +6,5 @@ LL |         &None => 1
 LL |         &Some(2) => { 3 }
    |                  ^^ expected one of `,`, `.`, `?`, `}`, or an operator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/missing/missing-derivable-attr.stderr b/tests/ui/missing/missing-derivable-attr.stderr
index 9b8c0c583a1..f2e23b62fce 100644
--- a/tests/ui/missing/missing-derivable-attr.stderr
+++ b/tests/ui/missing/missing-derivable-attr.stderr
@@ -7,6 +7,6 @@ LL |     fn eq(&self, other: &Self) -> bool;
 LL | impl MyEq for A {}
    | ^^^^^^^^^^^^^^^ missing `eq` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/missing/missing-fields-in-struct-pattern.stderr b/tests/ui/missing/missing-fields-in-struct-pattern.stderr
index 1fe9f5299aa..91a7bd3540e 100644
--- a/tests/ui/missing/missing-fields-in-struct-pattern.stderr
+++ b/tests/ui/missing/missing-fields-in-struct-pattern.stderr
@@ -9,6 +9,6 @@ help: use the tuple variant pattern syntax instead
 LL |     if let S(a, b, c, d) = S(1, 2, 3, 4) {
    |             ~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0769`.
diff --git a/tests/ui/missing/missing-items/m2.stderr b/tests/ui/missing/missing-items/m2.stderr
index 835c9b2aa48..c552abccee4 100644
--- a/tests/ui/missing/missing-items/m2.stderr
+++ b/tests/ui/missing/missing-items/m2.stderr
@@ -12,6 +12,6 @@ LL | impl m1::X for X {
    = help: implement the missing item: `fn method4(&self, _: &Self) -> <Self as m1::X>::Type { todo!() }`
    = help: implement the missing item: `fn method5(self: &Box<Self>) -> <Self as m1::X>::Type { todo!() }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/missing/missing-items/missing-type-parameter.stderr b/tests/ui/missing/missing-items/missing-type-parameter.stderr
index 722539fca6b..658e2c8e85e 100644
--- a/tests/ui/missing/missing-items/missing-type-parameter.stderr
+++ b/tests/ui/missing/missing-items/missing-type-parameter.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     foo::<X>();
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/missing/missing-macro-use.stderr b/tests/ui/missing/missing-macro-use.stderr
index e1d80f52dad..5d8ff486e06 100644
--- a/tests/ui/missing/missing-macro-use.stderr
+++ b/tests/ui/missing/missing-macro-use.stderr
@@ -9,5 +9,5 @@ help: consider importing this macro
 LL + use two_macros::macro_two;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/missing/missing-main.stderr b/tests/ui/missing/missing-main.stderr
index 5113dc6ec08..2139981eac0 100644
--- a/tests/ui/missing/missing-main.stderr
+++ b/tests/ui/missing/missing-main.stderr
@@ -4,6 +4,6 @@ error[E0601]: `main` function not found in crate `missing_main`
 LL | fn mian() { }
    |              ^ consider adding a `main` function to `$DIR/missing-main.rs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/missing/missing-return.stderr b/tests/ui/missing/missing-return.stderr
index ff7f261e03c..5f7fb504075 100644
--- a/tests/ui/missing/missing-return.stderr
+++ b/tests/ui/missing/missing-return.stderr
@@ -6,6 +6,6 @@ LL | fn f() -> isize { }
    |    |
    |    implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod.stderr b/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod.stderr
index 5f4d19439ac..4e48799318b 100644
--- a/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod.stderr
+++ b/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod.stderr
@@ -7,6 +7,6 @@ LL | mod missing;
    = help: to create the module `missing`, create file "$DIR/foo/missing.rs" or "$DIR/foo/missing/mod.rs"
    = note: if there is a `mod missing` elsewhere in the crate already, import it with `use crate::...` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0583`.
diff --git a/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod_inline.stderr b/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod_inline.stderr
index d5f5ea87059..86193dd26e0 100644
--- a/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod_inline.stderr
+++ b/tests/ui/missing_non_modrs_mod/missing_non_modrs_mod_inline.stderr
@@ -7,6 +7,6 @@ LL |     mod missing;
    = help: to create the module `missing`, create file "$DIR/foo_inline/inline/missing.rs" or "$DIR/foo_inline/inline/missing/mod.rs"
    = note: if there is a `mod missing` elsewhere in the crate already, import it with `use crate::...` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0583`.
diff --git a/tests/ui/mod-subitem-as-enum-variant.stderr b/tests/ui/mod-subitem-as-enum-variant.stderr
index cf61e94bd86..92d972eba42 100644
--- a/tests/ui/mod-subitem-as-enum-variant.stderr
+++ b/tests/ui/mod-subitem-as-enum-variant.stderr
@@ -6,6 +6,6 @@ LL |     Mod::<i32>::FakeVariant(0);
    |     |
    |     not allowed on module `Mod`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/module-macro_use-arguments.stderr b/tests/ui/module-macro_use-arguments.stderr
index af799cb6ddf..3ac645ad3a9 100644
--- a/tests/ui/module-macro_use-arguments.stderr
+++ b/tests/ui/module-macro_use-arguments.stderr
@@ -4,5 +4,5 @@ error: arguments to `macro_use` are not allowed here
 LL | #[macro_use(foo, bar)]
    | ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/modules/issue-107649.stderr b/tests/ui/modules/issue-107649.stderr
index 5705e84e0d9..0d203c1aacb 100644
--- a/tests/ui/modules/issue-107649.stderr
+++ b/tests/ui/modules/issue-107649.stderr
@@ -14,6 +14,6 @@ help: consider annotating `Dummy` with `#[derive(Debug)]`
 3   | pub struct Dummy;
     |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/modules/path-invalid-form.stderr b/tests/ui/modules/path-invalid-form.stderr
index 7e8aa44ef8b..e8ded1343f7 100644
--- a/tests/ui/modules/path-invalid-form.stderr
+++ b/tests/ui/modules/path-invalid-form.stderr
@@ -4,5 +4,5 @@ error: malformed `path` attribute input
 LL | #[path = 123]
    | ^^^^^^^^^^^^^ help: must be of the form: `#[path = "file"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/modules/path-macro.stderr b/tests/ui/modules/path-macro.stderr
index 9a2e01ea264..eb02c721edd 100644
--- a/tests/ui/modules/path-macro.stderr
+++ b/tests/ui/modules/path-macro.stderr
@@ -4,5 +4,5 @@ error: malformed `path` attribute input
 LL | #[path = foo!()]
    | ^^^^^^^^^^^^^^^^ help: must be of the form: `#[path = "file"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/modules/path-no-file-name.stderr b/tests/ui/modules/path-no-file-name.stderr
index 32a213c68f6..834e8ea6b03 100644
--- a/tests/ui/modules/path-no-file-name.stderr
+++ b/tests/ui/modules/path-no-file-name.stderr
@@ -4,5 +4,5 @@ error: couldn't read $DIR/.: $ACCESS_DENIED_MSG (os error $ACCESS_DENIED_CODE)
 LL | mod m;
    | ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/modules_and_files_visibility/mod_file_correct_spans.stderr b/tests/ui/modules_and_files_visibility/mod_file_correct_spans.stderr
index 73044752b07..3426505cd11 100644
--- a/tests/ui/modules_and_files_visibility/mod_file_correct_spans.stderr
+++ b/tests/ui/modules_and_files_visibility/mod_file_correct_spans.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `bar` in module `mod_file_aux`
 LL |     assert!(mod_file_aux::bar() == 10);
    |                           ^^^ not found in `mod_file_aux`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/moves/issue-34721.stderr b/tests/ui/moves/issue-34721.stderr
index f2bf22227db..94780a04c1f 100644
--- a/tests/ui/moves/issue-34721.stderr
+++ b/tests/ui/moves/issue-34721.stderr
@@ -23,6 +23,6 @@ help: consider further restricting this bound
 LL |     pub fn baz<T: Foo + Copy>(x: T) -> T {
    |                       ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/issue-46099-move-in-macro.stderr b/tests/ui/moves/issue-46099-move-in-macro.stderr
index 94bc9e6f454..2865a4e2ba1 100644
--- a/tests/ui/moves/issue-46099-move-in-macro.stderr
+++ b/tests/ui/moves/issue-46099-move-in-macro.stderr
@@ -11,6 +11,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     test!({b.clone()});
    |             ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/issue-75904-move-closure-loop.stderr b/tests/ui/moves/issue-75904-move-closure-loop.stderr
index 5e427a1fcdc..6f04105a35e 100644
--- a/tests/ui/moves/issue-75904-move-closure-loop.stderr
+++ b/tests/ui/moves/issue-75904-move-closure-loop.stderr
@@ -10,6 +10,6 @@ LL |             &mut a;
 LL |             a;
    |             - use occurs due to use in closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/issue-99470-move-out-of-some.stderr b/tests/ui/moves/issue-99470-move-out-of-some.stderr
index c5159471fe3..71ec5adfdea 100644
--- a/tests/ui/moves/issue-99470-move-out-of-some.stderr
+++ b/tests/ui/moves/issue-99470-move-out-of-some.stderr
@@ -16,6 +16,6 @@ LL -         &Some(_y) => (),
 LL +         Some(_y) => (),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/move-guard-same-consts.stderr b/tests/ui/moves/move-guard-same-consts.stderr
index 86e5f65248b..37ddb831abe 100644
--- a/tests/ui/moves/move-guard-same-consts.stderr
+++ b/tests/ui/moves/move-guard-same-consts.stderr
@@ -21,6 +21,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         (1, 2) if take(x.clone()) => (),
    |                         ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-in-guard-1.stderr b/tests/ui/moves/move-in-guard-1.stderr
index f04cb34d7c4..0b90823884a 100644
--- a/tests/ui/moves/move-in-guard-1.stderr
+++ b/tests/ui/moves/move-in-guard-1.stderr
@@ -21,6 +21,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         (1, _) if take(x.clone()) => (),
    |                         ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-in-guard-2.stderr b/tests/ui/moves/move-in-guard-2.stderr
index 26047861f55..6d1bd4f9553 100644
--- a/tests/ui/moves/move-in-guard-2.stderr
+++ b/tests/ui/moves/move-in-guard-2.stderr
@@ -19,6 +19,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         (_, 2) if take(x.clone()) => (),
    |                         ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-into-dead-array-1.stderr b/tests/ui/moves/move-into-dead-array-1.stderr
index 6db0f0bcbff..83779fb16ed 100644
--- a/tests/ui/moves/move-into-dead-array-1.stderr
+++ b/tests/ui/moves/move-into-dead-array-1.stderr
@@ -11,6 +11,6 @@ help: consider assigning a value
 LL |     let mut a: [D; 4] = todo!();
    |                       +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/moves/move-into-dead-array-2.stderr b/tests/ui/moves/move-into-dead-array-2.stderr
index 19e476c04ea..689aecdfc8c 100644
--- a/tests/ui/moves/move-into-dead-array-2.stderr
+++ b/tests/ui/moves/move-into-dead-array-2.stderr
@@ -8,6 +8,6 @@ LL |     drop(a);
 LL |     a[i] = d();
    |     ^^^^ value used here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-of-addr-of-mut.stderr b/tests/ui/moves/move-of-addr-of-mut.stderr
index ddebaa0129a..706b52d3402 100644
--- a/tests/ui/moves/move-of-addr-of-mut.stderr
+++ b/tests/ui/moves/move-of-addr-of-mut.stderr
@@ -12,6 +12,6 @@ help: consider assigning a value
 LL |     let mut x: S = todo!();
    |                  +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/moves/move-out-of-array-1.stderr b/tests/ui/moves/move-out-of-array-1.stderr
index 0af083e5b52..aa0251dbd85 100644
--- a/tests/ui/moves/move-out-of-array-1.stderr
+++ b/tests/ui/moves/move-out-of-array-1.stderr
@@ -7,6 +7,6 @@ LL |     a[i]
    |     cannot move out of here
    |     move occurs because `a[_]` has type `D`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/moves/move-out-of-slice-1.stderr b/tests/ui/moves/move-out-of-slice-1.stderr
index 5a0357cf567..86533714474 100644
--- a/tests/ui/moves/move-out-of-slice-1.stderr
+++ b/tests/ui/moves/move-out-of-slice-1.stderr
@@ -14,6 +14,6 @@ help: consider borrowing the pattern binding
 LL |         box [ref a] => {},
    |              +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/moves/moves-based-on-type-access-to-field.stderr b/tests/ui/moves/moves-based-on-type-access-to-field.stderr
index 73901866396..1e656e686fd 100644
--- a/tests/ui/moves/moves-based-on-type-access-to-field.stderr
+++ b/tests/ui/moves/moves-based-on-type-access-to-field.stderr
@@ -15,6 +15,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |     consume(x.clone().into_iter().next().unwrap());
    |              ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-block-bad.stderr b/tests/ui/moves/moves-based-on-type-block-bad.stderr
index df09ababa5a..431ee1c0bb1 100644
--- a/tests/ui/moves/moves-based-on-type-block-bad.stderr
+++ b/tests/ui/moves/moves-based-on-type-block-bad.stderr
@@ -15,6 +15,6 @@ help: consider borrowing here
 LL |             match &hellothere.x {
    |                   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr b/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr
index 34b7ea65867..5e527bf445e 100644
--- a/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr
+++ b/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr
@@ -13,6 +13,6 @@ LL |     println!("{}", x);
    |
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr b/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr
index db4382b58fc..ec483cb3d09 100644
--- a/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr
+++ b/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr
@@ -13,6 +13,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |         Some(ref right) => consume(right),
    |              +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-match-bindings.stderr b/tests/ui/moves/moves-based-on-type-match-bindings.stderr
index 225935532ea..b99b2bd9eef 100644
--- a/tests/ui/moves/moves-based-on-type-match-bindings.stderr
+++ b/tests/ui/moves/moves-based-on-type-match-bindings.stderr
@@ -13,6 +13,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |         Foo {ref f} => {}
    |              +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
index 125e446c332..513631b2060 100644
--- a/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
+++ b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
@@ -8,6 +8,6 @@ LL |     let _f = to_fn(|| test(i));
    |                    |
    |                    captured by this `Fn` closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/moves-based-on-type-tuple.stderr b/tests/ui/moves/moves-based-on-type-tuple.stderr
index 0bcce301263..6383e4a823d 100644
--- a/tests/ui/moves/moves-based-on-type-tuple.stderr
+++ b/tests/ui/moves/moves-based-on-type-tuple.stderr
@@ -14,6 +14,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     Box::new((x.clone(), x))
    |                ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-sru-moved-field.stderr b/tests/ui/moves/moves-sru-moved-field.stderr
index cf7213637ce..f6a5c02ad2c 100644
--- a/tests/ui/moves/moves-sru-moved-field.stderr
+++ b/tests/ui/moves/moves-sru-moved-field.stderr
@@ -8,6 +8,6 @@ LL |     let _c = Foo {noncopyable: h, ..f};
    |
    = note: move occurs because `f.moved` has type `Box<isize>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/pin-mut-reborrow-infer-var-issue-107419.stderr b/tests/ui/moves/pin-mut-reborrow-infer-var-issue-107419.stderr
index a184482a446..bb179e1497b 100644
--- a/tests/ui/moves/pin-mut-reborrow-infer-var-issue-107419.stderr
+++ b/tests/ui/moves/pin-mut-reborrow-infer-var-issue-107419.stderr
@@ -15,6 +15,6 @@ help: consider reborrowing the `Pin` instead of moving it
 LL |     foo(r.as_mut().get_mut());
    |          +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/pin-mut-reborrow.stderr b/tests/ui/moves/pin-mut-reborrow.stderr
index 4bf207e7e98..d3ccb0a654e 100644
--- a/tests/ui/moves/pin-mut-reborrow.stderr
+++ b/tests/ui/moves/pin-mut-reborrow.stderr
@@ -18,6 +18,6 @@ help: consider reborrowing the `Pin` instead of moving it
 LL |     foo.as_mut().foo();
    |        +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/suggest-clone.stderr b/tests/ui/moves/suggest-clone.stderr
index 065acf904a4..e0b68f249ee 100644
--- a/tests/ui/moves/suggest-clone.stderr
+++ b/tests/ui/moves/suggest-clone.stderr
@@ -16,6 +16,6 @@ help: you can `clone` the value and consume it, but this might not be your desir
 LL |     foo.clone().foo();
    |        ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr b/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr
index 0bb486a8893..785329565eb 100644
--- a/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr
+++ b/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr
@@ -13,6 +13,6 @@ help: clone the value to increment its reference count
 LL |     (t.clone(), t)
    |       ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/mut/mut-cant-alias.stderr b/tests/ui/mut/mut-cant-alias.stderr
index d56e45db13d..4106ebdd1cb 100644
--- a/tests/ui/mut/mut-cant-alias.stderr
+++ b/tests/ui/mut/mut-cant-alias.stderr
@@ -8,6 +8,6 @@ LL |     let b2 = &mut *b;
 LL |     b1.use_mut();
    |     -- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/mut/mut-cross-borrowing.stderr b/tests/ui/mut/mut-cross-borrowing.stderr
index 8a3076db9b2..4cfe56bfab6 100644
--- a/tests/ui/mut/mut-cross-borrowing.stderr
+++ b/tests/ui/mut/mut-cross-borrowing.stderr
@@ -18,6 +18,6 @@ help: consider mutably borrowing here
 LL |     f(&mut x)
    |       ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/mut/mut-ref.stderr b/tests/ui/mut/mut-ref.stderr
index e6d4901aafb..b91392f223a 100644
--- a/tests/ui/mut/mut-ref.stderr
+++ b/tests/ui/mut/mut-ref.stderr
@@ -4,5 +4,5 @@ error: the order of `mut` and `ref` is incorrect
 LL |     let mut ref x = 10;
    |         ^^^^^^^ help: try switching the order: `ref mut`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/mut/mutable-class-fields-2.stderr b/tests/ui/mut/mutable-class-fields-2.stderr
index c53c6ea302c..eb0c54f885b 100644
--- a/tests/ui/mut/mutable-class-fields-2.stderr
+++ b/tests/ui/mut/mutable-class-fields-2.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |   pub fn eat(&mut self) {
    |              ~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/mut/mutable-class-fields.stderr b/tests/ui/mut/mutable-class-fields.stderr
index 1d731be8a85..e57cce62ee4 100644
--- a/tests/ui/mut/mutable-class-fields.stderr
+++ b/tests/ui/mut/mutable-class-fields.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |   let mut nyan : Cat = cat(52, 99);
    |       +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/mut/mutable-enum-indirect.stderr b/tests/ui/mut/mutable-enum-indirect.stderr
index 9e1f4e1fe4e..0b7783b3318 100644
--- a/tests/ui/mut/mutable-enum-indirect.stderr
+++ b/tests/ui/mut/mutable-enum-indirect.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Sync>(_: T) {}
    |           ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/native-library-link-flags/modifiers-override-3.stderr b/tests/ui/native-library-link-flags/modifiers-override-3.stderr
index 365e5618100..3eb9459f6f3 100644
--- a/tests/ui/native-library-link-flags/modifiers-override-3.stderr
+++ b/tests/ui/native-library-link-flags/modifiers-override-3.stderr
@@ -1,4 +1,4 @@
 error: overriding linking modifiers from command line is not supported
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/native-library-link-flags/suggest-libname-only-1.stderr b/tests/ui/native-library-link-flags/suggest-libname-only-1.stderr
index 64d0a9077ed..e142835a9d6 100644
--- a/tests/ui/native-library-link-flags/suggest-libname-only-1.stderr
+++ b/tests/ui/native-library-link-flags/suggest-libname-only-1.stderr
@@ -2,5 +2,5 @@ error: could not find native static library `libfoo.a`, perhaps an -L flag is mi
    |
    = help: only provide the library name `foo`, not the full filename
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/native-library-link-flags/suggest-libname-only-2.stderr b/tests/ui/native-library-link-flags/suggest-libname-only-2.stderr
index e166af9ed8f..392d2f01f61 100644
--- a/tests/ui/native-library-link-flags/suggest-libname-only-2.stderr
+++ b/tests/ui/native-library-link-flags/suggest-libname-only-2.stderr
@@ -2,5 +2,5 @@ error: could not find native static library `bar.lib`, perhaps an -L flag is mis
    |
    = help: only provide the library name `bar`, not the full filename
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nested-cfg-attrs.stderr b/tests/ui/nested-cfg-attrs.stderr
index f63888b2f8a..16c29307143 100644
--- a/tests/ui/nested-cfg-attrs.stderr
+++ b/tests/ui/nested-cfg-attrs.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `f` in this scope
 LL | fn main() { f() }
    |             ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/never_type/call-fn-never-arg-wrong-type.stderr b/tests/ui/never_type/call-fn-never-arg-wrong-type.stderr
index fa3db33c960..bdeb2fb906c 100644
--- a/tests/ui/never_type/call-fn-never-arg-wrong-type.stderr
+++ b/tests/ui/never_type/call-fn-never-arg-wrong-type.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn foo(x: !) -> ! {
    |    ^^^ ----
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/never_type/defaulted-never-note.fallback.stderr b/tests/ui/never_type/defaulted-never-note.fallback.stderr
index 283aca1b084..92fa9068cfd 100644
--- a/tests/ui/never_type/defaulted-never-note.fallback.stderr
+++ b/tests/ui/never_type/defaulted-never-note.fallback.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `foo`
 LL | fn foo<T: ImplementedForUnitButNotNever>(_t: T) {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/diverging-fallback-no-leak.fallback.stderr b/tests/ui/never_type/diverging-fallback-no-leak.fallback.stderr
index df29fe22713..ff28480bd99 100644
--- a/tests/ui/never_type/diverging-fallback-no-leak.fallback.stderr
+++ b/tests/ui/never_type/diverging-fallback-no-leak.fallback.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `unconstrained_arg`
 LL | fn unconstrained_arg<T: Test>(_: T) {}
    |                         ^^^^ required by this bound in `unconstrained_arg`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/exhaustive_patterns.stderr b/tests/ui/never_type/exhaustive_patterns.stderr
index f7bf8581582..ee7d9070cd3 100644
--- a/tests/ui/never_type/exhaustive_patterns.stderr
+++ b/tests/ui/never_type/exhaustive_patterns.stderr
@@ -21,6 +21,6 @@ help: you might want to use `if let` to ignore the variant that isn't matched
 LL |     if let Either::A(()) = foo() { todo!() };
    |     ++                           +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/never_type/fallback-closure-wrap.fallback.stderr b/tests/ui/never_type/fallback-closure-wrap.fallback.stderr
index 49f55db1e25..aa4a2760ffd 100644
--- a/tests/ui/never_type/fallback-closure-wrap.fallback.stderr
+++ b/tests/ui/never_type/fallback-closure-wrap.fallback.stderr
@@ -12,6 +12,6 @@ LL | |     }) as Box<dyn FnMut()>);
                    found type `!`
    = note: required for the cast from `Box<{closure@$DIR/fallback-closure-wrap.rs:18:40: 18:47}>` to `Box<dyn FnMut()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/never_type/feature-gate-never_type_fallback.stderr b/tests/ui/never_type/feature-gate-never_type_fallback.stderr
index 56aafbb4ce8..cbb670ea708 100644
--- a/tests/ui/never_type/feature-gate-never_type_fallback.stderr
+++ b/tests/ui/never_type/feature-gate-never_type_fallback.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `foo`
 LL | fn foo(_: impl T) {}
    |                ^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/impl_trait_fallback3.stderr b/tests/ui/never_type/impl_trait_fallback3.stderr
index 821d141569e..e2246eea17c 100644
--- a/tests/ui/never_type/impl_trait_fallback3.stderr
+++ b/tests/ui/never_type/impl_trait_fallback3.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait T {
    | ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/impl_trait_fallback4.stderr b/tests/ui/never_type/impl_trait_fallback4.stderr
index 67421ba8da7..8f6b5cfea68 100644
--- a/tests/ui/never_type/impl_trait_fallback4.stderr
+++ b/tests/ui/never_type/impl_trait_fallback4.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait T {
    | ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/issue-10176.stderr b/tests/ui/never_type/issue-10176.stderr
index 3f381b9aea9..cd6473e0682 100644
--- a/tests/ui/never_type/issue-10176.stderr
+++ b/tests/ui/never_type/issue-10176.stderr
@@ -9,6 +9,6 @@ LL |     (return 1, return 2)
    = note: expected type `isize`
              found tuple `(!, !)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/never_type/issue-13352.stderr b/tests/ui/never_type/issue-13352.stderr
index 406785bfea0..91885380b1f 100644
--- a/tests/ui/never_type/issue-13352.stderr
+++ b/tests/ui/never_type/issue-13352.stderr
@@ -11,6 +11,6 @@ LL |     2_usize + (loop {});
              <&'a usize as Add<usize>>
              <&usize as Add<&usize>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/issue-51506.stderr b/tests/ui/never_type/issue-51506.stderr
index 293ec3a725d..09379257c4c 100644
--- a/tests/ui/never_type/issue-51506.stderr
+++ b/tests/ui/never_type/issue-51506.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `Trait::Out`
 LL |     type Out: Iterator<Item = u32>;
    |               ^^^^^^^^^^^^^^^^^^^^ required by this bound in `Trait::Out`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/never_type/never-assign-wrong-type.stderr b/tests/ui/never_type/never-assign-wrong-type.stderr
index ce34d948324..f59de5d2a42 100644
--- a/tests/ui/never_type/never-assign-wrong-type.stderr
+++ b/tests/ui/never_type/never-assign-wrong-type.stderr
@@ -9,6 +9,6 @@ LL |     let x: ! = "hello";
    = note:   expected type `!`
            found reference `&'static str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/never_type/never-from-impl-is-reserved.current.stderr b/tests/ui/never_type/never-from-impl-is-reserved.current.stderr
index 6c71785de28..d008f88c188 100644
--- a/tests/ui/never_type/never-from-impl-is-reserved.current.stderr
+++ b/tests/ui/never_type/never-from-impl-is-reserved.current.stderr
@@ -9,6 +9,6 @@ LL | impl<T> MyTrait for T where T: From<!> {}
    |
    = note: permitting this impl would forbid us from adding `impl<T> From<!> for T` later; see rust-lang/rust#64715 for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/never_type/never-from-impl-is-reserved.next.stderr b/tests/ui/never_type/never-from-impl-is-reserved.next.stderr
index 6c71785de28..d008f88c188 100644
--- a/tests/ui/never_type/never-from-impl-is-reserved.next.stderr
+++ b/tests/ui/never_type/never-from-impl-is-reserved.next.stderr
@@ -9,6 +9,6 @@ LL | impl<T> MyTrait for T where T: From<!> {}
    |
    = note: permitting this impl would forbid us from adding `impl<T> From<!> for T` later; see rust-lang/rust#64715 for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/never_type/never-value-fallback-issue-66757.nofallback.stderr b/tests/ui/never_type/never-value-fallback-issue-66757.nofallback.stderr
index cb378630589..f5249814c78 100644
--- a/tests/ui/never_type/never-value-fallback-issue-66757.nofallback.stderr
+++ b/tests/ui/never_type/never-value-fallback-issue-66757.nofallback.stderr
@@ -7,6 +7,6 @@ LL |     <E as From<_>>::from(never);
    = help: the trait `From<!>` is implemented for `E`
    = help: for that trait implementation, expected `!`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/nll/borrowed-local-error.stderr b/tests/ui/nll/borrowed-local-error.stderr
index 1cca4077d82..acefdea97d3 100644
--- a/tests/ui/nll/borrowed-local-error.stderr
+++ b/tests/ui/nll/borrowed-local-error.stderr
@@ -11,6 +11,6 @@ LL |
 LL |     });
    |     - `v` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/borrowed-match-issue-45045.stderr b/tests/ui/nll/borrowed-match-issue-45045.stderr
index 33e3eb79796..b2ec724f309 100644
--- a/tests/ui/nll/borrowed-match-issue-45045.stderr
+++ b/tests/ui/nll/borrowed-match-issue-45045.stderr
@@ -10,6 +10,6 @@ LL |     match e {
 LL |     *g = Xyz::B;
    |     ----------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/nll/borrowed-referent-issue-38899.stderr b/tests/ui/nll/borrowed-referent-issue-38899.stderr
index 16588cbcfb2..7075965289b 100644
--- a/tests/ui/nll/borrowed-referent-issue-38899.stderr
+++ b/tests/ui/nll/borrowed-referent-issue-38899.stderr
@@ -10,6 +10,6 @@ LL |
 LL |     drop(x);
    |          - mutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/nll/borrowed-temporary-error.stderr b/tests/ui/nll/borrowed-temporary-error.stderr
index 89781d96fab..a17de890e3f 100644
--- a/tests/ui/nll/borrowed-temporary-error.stderr
+++ b/tests/ui/nll/borrowed-temporary-error.stderr
@@ -11,6 +11,6 @@ LL |     println!("{:?}", x);
    |
    = note: consider using a `let` binding to create a longer lived value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/nll/borrowed-universal-error-2.stderr b/tests/ui/nll/borrowed-universal-error-2.stderr
index 7213ed3bafb..aa31142b24e 100644
--- a/tests/ui/nll/borrowed-universal-error-2.stderr
+++ b/tests/ui/nll/borrowed-universal-error-2.stderr
@@ -4,6 +4,6 @@ error[E0515]: cannot return reference to local variable `v`
 LL |     &v
    |     ^^ returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/borrowed-universal-error.stderr b/tests/ui/nll/borrowed-universal-error.stderr
index 88a2d8fcf8c..d93e2ffc85c 100644
--- a/tests/ui/nll/borrowed-universal-error.stderr
+++ b/tests/ui/nll/borrowed-universal-error.stderr
@@ -7,6 +7,6 @@ LL |     gimme(&(v,))
    |     |      temporary value created here
    |     returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/capture-mut-ref.stderr b/tests/ui/nll/capture-mut-ref.stderr
index 4898d569235..d76e031466d 100644
--- a/tests/ui/nll/capture-mut-ref.stderr
+++ b/tests/ui/nll/capture-mut-ref.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unused_mut)]
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/capture-ref-in-struct.stderr b/tests/ui/nll/capture-ref-in-struct.stderr
index 84b7ecf2f7d..81b937051c2 100644
--- a/tests/ui/nll/capture-ref-in-struct.stderr
+++ b/tests/ui/nll/capture-ref-in-struct.stderr
@@ -13,6 +13,6 @@ LL |
 LL |     deref(p);
    |           - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/closure-requirements/escape-argument-callee.stderr b/tests/ui/nll/closure-requirements/escape-argument-callee.stderr
index a8f6559e425..8debea6a0a2 100644
--- a/tests/ui/nll/closure-requirements/escape-argument-callee.stderr
+++ b/tests/ui/nll/closure-requirements/escape-argument-callee.stderr
@@ -27,5 +27,5 @@ LL | fn test() {
    |
    = note: defining type: test
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/escape-argument.stderr b/tests/ui/nll/closure-requirements/escape-argument.stderr
index 40f04bb6da6..b050c0566c6 100644
--- a/tests/ui/nll/closure-requirements/escape-argument.stderr
+++ b/tests/ui/nll/closure-requirements/escape-argument.stderr
@@ -33,6 +33,6 @@ LL |
 LL |     deref(p);
    |           - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/closure-requirements/escape-upvar-nested.stderr b/tests/ui/nll/closure-requirements/escape-upvar-nested.stderr
index 727df1cf890..aa73e91cc77 100644
--- a/tests/ui/nll/closure-requirements/escape-upvar-nested.stderr
+++ b/tests/ui/nll/closure-requirements/escape-upvar-nested.stderr
@@ -48,6 +48,6 @@ LL |
 LL |     deref(p);
    |           - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/closure-requirements/escape-upvar-ref.stderr b/tests/ui/nll/closure-requirements/escape-upvar-ref.stderr
index ff638f2a1ec..949dcc78703 100644
--- a/tests/ui/nll/closure-requirements/escape-upvar-ref.stderr
+++ b/tests/ui/nll/closure-requirements/escape-upvar-ref.stderr
@@ -34,6 +34,6 @@ LL |
 LL |     deref(p);
    |           - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-fail-no-postdom.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-fail-no-postdom.stderr
index ef2cb4067d7..bffd365b9cc 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-fail-no-postdom.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-fail-no-postdom.stderr
@@ -32,5 +32,5 @@ LL | fn supply<'a, 'b, 'c>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>, cell_c:
    |
    = note: defining type: supply
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-ref.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-ref.stderr
index db48a4ce70c..843d307b80b 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-ref.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-ref.stderr
@@ -35,5 +35,5 @@ LL |         demand_y(x, y, x.get())
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
index ffd526d90af..54784df5275 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
@@ -44,6 +44,6 @@ LL | |     });
    = note: the struct `Cell<T>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
index 726d0dc2a4c..53547afbfea 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
@@ -44,6 +44,6 @@ LL | |     });
    = note: the struct `Cell<T>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-val.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-val.stderr
index 5a65c768448..5566c76d854 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-val.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-val.stderr
@@ -35,5 +35,5 @@ LL |         demand_y(outlives1, outlives2, x.get())
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-no-bounds.stderr b/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-no-bounds.stderr
index f7a0ee9b18d..64deaa00fa3 100644
--- a/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-no-bounds.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-no-bounds.stderr
@@ -31,5 +31,5 @@ LL | fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
    |
    = note: defining type: supply
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-wrong-bounds.stderr b/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-wrong-bounds.stderr
index fa9fa9e8f3c..ee49b4dac22 100644
--- a/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-wrong-bounds.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-wrong-bounds.stderr
@@ -31,5 +31,5 @@ LL | fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
    |
    = note: defining type: supply
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr b/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
index a20f885fe81..28c5c43a6ac 100644
--- a/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
@@ -36,6 +36,6 @@ help: consider adding an explicit lifetime bound
 LL |     T: Trait<'a> + 'a,
    |                  ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
index 2fec9bc62d1..81b5f09b041 100644
--- a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
@@ -12,6 +12,6 @@ LL |         z = &local_arr;
 LL | }
    | - `local_arr` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/closure-requirements/region-lbr-anon-does-not-outlive-static.stderr b/tests/ui/nll/closure-requirements/region-lbr-anon-does-not-outlive-static.stderr
index 7034492cee0..0f3e9314d93 100644
--- a/tests/ui/nll/closure-requirements/region-lbr-anon-does-not-outlive-static.stderr
+++ b/tests/ui/nll/closure-requirements/region-lbr-anon-does-not-outlive-static.stderr
@@ -6,5 +6,5 @@ LL | fn foo(x: &u32) -> &'static u32 {
 LL |     &*x
    |     ^^^ returning this value requires that `'1` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/region-lbr-named-does-not-outlive-static.stderr b/tests/ui/nll/closure-requirements/region-lbr-named-does-not-outlive-static.stderr
index d0a24a267fd..36478e723cc 100644
--- a/tests/ui/nll/closure-requirements/region-lbr-named-does-not-outlive-static.stderr
+++ b/tests/ui/nll/closure-requirements/region-lbr-named-does-not-outlive-static.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a>(x: &'a u32) -> &'static u32 {
 LL |     &*x
    |     ^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/region-lbr1-does-not-outlive-ebr2.stderr b/tests/ui/nll/closure-requirements/region-lbr1-does-not-outlive-ebr2.stderr
index d0ba5392532..9a0f4bb6d9a 100644
--- a/tests/ui/nll/closure-requirements/region-lbr1-does-not-outlive-ebr2.stderr
+++ b/tests/ui/nll/closure-requirements/region-lbr1-does-not-outlive-ebr2.stderr
@@ -10,5 +10,5 @@ LL |     &*x
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-requirements/return-wrong-bound-region.stderr b/tests/ui/nll/closure-requirements/return-wrong-bound-region.stderr
index 35e4a16c8da..a13caf8c298 100644
--- a/tests/ui/nll/closure-requirements/return-wrong-bound-region.stderr
+++ b/tests/ui/nll/closure-requirements/return-wrong-bound-region.stderr
@@ -27,5 +27,5 @@ LL | fn test() {
    |
    = note: defining type: test
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/constant-thread-locals-issue-47053.stderr b/tests/ui/nll/constant-thread-locals-issue-47053.stderr
index a44acfb5fc3..1c6844d6e33 100644
--- a/tests/ui/nll/constant-thread-locals-issue-47053.stderr
+++ b/tests/ui/nll/constant-thread-locals-issue-47053.stderr
@@ -4,6 +4,6 @@ error[E0594]: cannot assign to immutable static item `FOO`
 LL |     FOO = 6;
    |     ^^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/nll/continue-after-missing-main.stderr b/tests/ui/nll/continue-after-missing-main.stderr
index 0df8d8d703e..960503e8fd5 100644
--- a/tests/ui/nll/continue-after-missing-main.stderr
+++ b/tests/ui/nll/continue-after-missing-main.stderr
@@ -4,6 +4,6 @@ error[E0601]: `main` function not found in crate `continue_after_missing_main`
 LL | }
    |  ^ consider adding a `main` function to `$DIR/continue-after-missing-main.rs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/nll/coroutine-upvar-mutability.stderr b/tests/ui/nll/coroutine-upvar-mutability.stderr
index 464bbc76931..8922eae3151 100644
--- a/tests/ui/nll/coroutine-upvar-mutability.stderr
+++ b/tests/ui/nll/coroutine-upvar-mutability.stderr
@@ -7,6 +7,6 @@ LL |     move || {
 LL |         x = 1;
    |         ^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/nll/decl-macro-illegal-copy.stderr b/tests/ui/nll/decl-macro-illegal-copy.stderr
index 7948485bd68..82fb8cdc915 100644
--- a/tests/ui/nll/decl-macro-illegal-copy.stderr
+++ b/tests/ui/nll/decl-macro-illegal-copy.stderr
@@ -9,6 +9,6 @@ LL |         wrapper.inner,
    |
    = note: move occurs because `wrapper.inner` has type `NonCopy`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy-proj.stderr b/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy-proj.stderr
index 862c925b468..6c96f474aec 100644
--- a/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy-proj.stderr
+++ b/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy-proj.stderr
@@ -11,6 +11,6 @@ LL |     drop(a.0);
 LL | }
    | - `s` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy.stderr b/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy.stderr
index ebaf6d1244d..d86ede62992 100644
--- a/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy.stderr
+++ b/tests/ui/nll/do-not-ignore-lifetime-bounds-in-copy.stderr
@@ -11,6 +11,6 @@ LL |     drop(a);
 LL | }
    | - `s` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-27282-mutate-before-diverging-arm-1.stderr b/tests/ui/nll/issue-27282-mutate-before-diverging-arm-1.stderr
index a1f973e0fdf..a37639883d2 100644
--- a/tests/ui/nll/issue-27282-mutate-before-diverging-arm-1.stderr
+++ b/tests/ui/nll/issue-27282-mutate-before-diverging-arm-1.stderr
@@ -9,6 +9,6 @@ LL |             (|| { *x = None; drop(force_fn_once); })();
    |              |
    |              cannot mutably borrow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0510`.
diff --git a/tests/ui/nll/issue-27282-mutate-before-diverging-arm-2.stderr b/tests/ui/nll/issue-27282-mutate-before-diverging-arm-2.stderr
index dd46308d140..5cd0982526b 100644
--- a/tests/ui/nll/issue-27282-mutate-before-diverging-arm-2.stderr
+++ b/tests/ui/nll/issue-27282-mutate-before-diverging-arm-2.stderr
@@ -9,6 +9,6 @@ LL |                 (|| { *x = None; drop(force_fn_once); })();
    |                  |
    |                  cannot mutably borrow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0510`.
diff --git a/tests/ui/nll/issue-27282-mutate-before-diverging-arm-3.stderr b/tests/ui/nll/issue-27282-mutate-before-diverging-arm-3.stderr
index 4a4a25790b9..e4d0cf31112 100644
--- a/tests/ui/nll/issue-27282-mutate-before-diverging-arm-3.stderr
+++ b/tests/ui/nll/issue-27282-mutate-before-diverging-arm-3.stderr
@@ -9,6 +9,6 @@ LL |             (|| { *x = &None; drop(force_fn_once); })();
    |              |
    |              cannot mutably borrow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0510`.
diff --git a/tests/ui/nll/issue-27868.stderr b/tests/ui/nll/issue-27868.stderr
index 204eda3d267..5e70b3017d5 100644
--- a/tests/ui/nll/issue-27868.stderr
+++ b/tests/ui/nll/issue-27868.stderr
@@ -13,6 +13,6 @@ LL | |         0
 LL | |     };
    | |_____- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/issue-30438-a.stderr b/tests/ui/nll/issue-30438-a.stderr
index 53845af82fb..73599f6b71f 100644
--- a/tests/ui/nll/issue-30438-a.stderr
+++ b/tests/ui/nll/issue-30438-a.stderr
@@ -7,6 +7,6 @@ LL |         return &Test { s: &self.s};
    |                |temporary value created here
    |                returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/issue-30438-b.stderr b/tests/ui/nll/issue-30438-b.stderr
index fd6bd25b1da..b8eb4632a02 100644
--- a/tests/ui/nll/issue-30438-b.stderr
+++ b/tests/ui/nll/issue-30438-b.stderr
@@ -7,6 +7,6 @@ LL |         &Test { s: &self.s}
    |         |temporary value created here
    |         returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/issue-30438-c.stderr b/tests/ui/nll/issue-30438-c.stderr
index 7c001088097..c8ca2bff74e 100644
--- a/tests/ui/nll/issue-30438-c.stderr
+++ b/tests/ui/nll/issue-30438-c.stderr
@@ -4,6 +4,6 @@ error[E0515]: cannot return reference to local variable `x`
 LL |     &x
    |     ^^ returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/issue-31567.stderr b/tests/ui/nll/issue-31567.stderr
index 7d43383e89f..0f35fc1bf19 100644
--- a/tests/ui/nll/issue-31567.stderr
+++ b/tests/ui/nll/issue-31567.stderr
@@ -11,6 +11,6 @@ LL |     &s_inner.0
 LL | }
    | - here, drop of `v` needs exclusive access to `*v.0`, because the type `VecWrapper<'_>` implements the `Drop` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0713`.
diff --git a/tests/ui/nll/issue-45157.stderr b/tests/ui/nll/issue-45157.stderr
index 57fd8d49c88..2dbf1c47de5 100644
--- a/tests/ui/nll/issue-45157.stderr
+++ b/tests/ui/nll/issue-45157.stderr
@@ -12,6 +12,6 @@ LL |         println!("{} {}", mref, nref)
    |
    = note: `u.z.c` is a field of the union `U`, so it overlaps the field `u.s.a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/nll/issue-46023.stderr b/tests/ui/nll/issue-46023.stderr
index ca19c250120..062e07407ce 100644
--- a/tests/ui/nll/issue-46023.stderr
+++ b/tests/ui/nll/issue-46023.stderr
@@ -7,6 +7,6 @@ LL |     let x = 0;
 LL |         x = 1;
    |         ^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/nll/issue-46036.stderr b/tests/ui/nll/issue-46036.stderr
index f337e234550..69753df14f6 100644
--- a/tests/ui/nll/issue-46036.stderr
+++ b/tests/ui/nll/issue-46036.stderr
@@ -12,6 +12,6 @@ LL |     loop { }
 LL | }
    | - `a` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-46589.stderr b/tests/ui/nll/issue-46589.stderr
index 82cd364eeff..abf62aaa510 100644
--- a/tests/ui/nll/issue-46589.stderr
+++ b/tests/ui/nll/issue-46589.stderr
@@ -10,6 +10,6 @@ LL |             None => (*other).new_self()
    |                     second mutable borrow occurs here
    |                     first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/nll/issue-47388.stderr b/tests/ui/nll/issue-47388.stderr
index 09b9d638afb..bd8b4c1eea0 100644
--- a/tests/ui/nll/issue-47388.stderr
+++ b/tests/ui/nll/issue-47388.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     let fancy_ref = &mut (&mut fancy);
    |                      +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/nll/issue-47470.stderr b/tests/ui/nll/issue-47470.stderr
index 0b1247d60ec..ae30f418284 100644
--- a/tests/ui/nll/issue-47470.stderr
+++ b/tests/ui/nll/issue-47470.stderr
@@ -4,6 +4,6 @@ error[E0515]: cannot return reference to local variable `local`
 LL |         &local
    |         ^^^^^^ returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/issue-48238.stderr b/tests/ui/nll/issue-48238.stderr
index 0aa1eedad9f..e15fbbdcdf2 100644
--- a/tests/ui/nll/issue-48238.stderr
+++ b/tests/ui/nll/issue-48238.stderr
@@ -9,5 +9,5 @@ LL |     move || use_val(&orig);
    |
    = note: closure implements `Fn`, so references to captured variables can't escape the closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-48697.stderr b/tests/ui/nll/issue-48697.stderr
index f0c29b72b42..243a6011741 100644
--- a/tests/ui/nll/issue-48697.stderr
+++ b/tests/ui/nll/issue-48697.stderr
@@ -6,6 +6,6 @@ LL |     let k = f(&z);
 LL |     f(x)
    |     ^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/issue-48803.stderr b/tests/ui/nll/issue-48803.stderr
index e24606e0b53..41dc7c8f9a4 100644
--- a/tests/ui/nll/issue-48803.stderr
+++ b/tests/ui/nll/issue-48803.stderr
@@ -10,6 +10,6 @@ LL |
 LL |     println!("{}", w); // prints "modified"
    |                    - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/issue-50716.stderr b/tests/ui/nll/issue-50716.stderr
index 38dd1b5f6fe..a09e7670515 100644
--- a/tests/ui/nll/issue-50716.stderr
+++ b/tests/ui/nll/issue-50716.stderr
@@ -7,5 +7,5 @@ LL | fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>)
 LL |     let _x = *s;
    |              ^^ proving this value is `Sized` requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-51244.stderr b/tests/ui/nll/issue-51244.stderr
index 8ccb5809e39..610482f8b1a 100644
--- a/tests/ui/nll/issue-51244.stderr
+++ b/tests/ui/nll/issue-51244.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     let ref mut my_ref @ _ = 0;
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/nll/issue-51268.stderr b/tests/ui/nll/issue-51268.stderr
index 0483bda6379..b0c3d8b878d 100644
--- a/tests/ui/nll/issue-51268.stderr
+++ b/tests/ui/nll/issue-51268.stderr
@@ -12,6 +12,6 @@ LL | |             &self.number;
 LL | |         });
    | |__________^ mutable borrow occurs here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/nll/issue-51512.stderr b/tests/ui/nll/issue-51512.stderr
index 072e96788b1..ed42899dc94 100644
--- a/tests/ui/nll/issue-51512.stderr
+++ b/tests/ui/nll/issue-51512.stderr
@@ -13,6 +13,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     let r = range.clone();
    |                  ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/nll/issue-52113.stderr b/tests/ui/nll/issue-52113.stderr
index 84d4eb266f1..0a5e2e5a4b7 100644
--- a/tests/ui/nll/issue-52113.stderr
+++ b/tests/ui/nll/issue-52113.stderr
@@ -11,5 +11,5 @@ LL |         data.push(value);
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-52213.stderr b/tests/ui/nll/issue-52213.stderr
index da31bcd5475..ed3723a7f03 100644
--- a/tests/ui/nll/issue-52213.stderr
+++ b/tests/ui/nll/issue-52213.stderr
@@ -11,5 +11,5 @@ LL |         ((u,),) => u,
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-52533-1.stderr b/tests/ui/nll/issue-52533-1.stderr
index 20f19b25967..b23ef3f33cc 100644
--- a/tests/ui/nll/issue-52533-1.stderr
+++ b/tests/ui/nll/issue-52533-1.stderr
@@ -7,5 +7,5 @@ LL |     gimme(|x, y| y)
    |            |  has type `&Foo<'_, '1, u32>`
    |            has type `&Foo<'_, '2, u32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-52534-2.stderr b/tests/ui/nll/issue-52534-2.stderr
index 35d39bb6e90..62715b836f6 100644
--- a/tests/ui/nll/issue-52534-2.stderr
+++ b/tests/ui/nll/issue-52534-2.stderr
@@ -12,6 +12,6 @@ LL |
 LL |     println!("{}", y);
    |                    - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr b/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr
index fb61b30f09d..587f3071027 100644
--- a/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr
+++ b/tests/ui/nll/issue-52663-span-decl-captured-variable.stderr
@@ -8,6 +8,6 @@ LL |        expect_fn(|| drop(x.0));
    |                  |
    |                  captured by this `Fn` closure
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/nll/issue-52663-trait-object.stderr b/tests/ui/nll/issue-52663-trait-object.stderr
index 338f6484132..fe55d8d49ad 100644
--- a/tests/ui/nll/issue-52663-trait-object.stderr
+++ b/tests/ui/nll/issue-52663-trait-object.stderr
@@ -10,6 +10,6 @@ LL |         Box::new(tmp1) as Box<dyn Foo + '_>
 LL |     };
    |     - `tmp0` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-52669.stderr b/tests/ui/nll/issue-52669.stderr
index db53e444b9e..f3cba9afb5c 100644
--- a/tests/ui/nll/issue-52669.stderr
+++ b/tests/ui/nll/issue-52669.stderr
@@ -9,6 +9,6 @@ LL |     foo(a);
 LL |     a.b.clone()
    |     ^^^ value borrowed here after move
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/nll/issue-52742.stderr b/tests/ui/nll/issue-52742.stderr
index a7973829656..8c09e542c05 100644
--- a/tests/ui/nll/issue-52742.stderr
+++ b/tests/ui/nll/issue-52742.stderr
@@ -8,5 +8,5 @@ LL |     fn take_bar(&mut self, b: Bar<'_>) {
 LL |         self.y = b.z
    |         ^^^^^^^^^^^^ assignment requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-53040.stderr b/tests/ui/nll/issue-53040.stderr
index 87ffe9b1abf..6c82459cc86 100644
--- a/tests/ui/nll/issue-53040.stderr
+++ b/tests/ui/nll/issue-53040.stderr
@@ -13,5 +13,5 @@ LL |     || &mut v;
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-53773.stderr b/tests/ui/nll/issue-53773.stderr
index fc185d42d5f..580f6727a88 100644
--- a/tests/ui/nll/issue-53773.stderr
+++ b/tests/ui/nll/issue-53773.stderr
@@ -11,6 +11,6 @@ LL |     }
    |
    = note: consider using a `let` binding to create a longer lived value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0713`.
diff --git a/tests/ui/nll/issue-53807.stderr b/tests/ui/nll/issue-53807.stderr
index d8f58b59131..b07e3669fe9 100644
--- a/tests/ui/nll/issue-53807.stderr
+++ b/tests/ui/nll/issue-53807.stderr
@@ -10,6 +10,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |         if let Some(ref thing) = maybe {
    |                     +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/nll/issue-54189.stderr b/tests/ui/nll/issue-54189.stderr
index 4787abd49d1..14ed2bb222d 100644
--- a/tests/ui/nll/issue-54189.stderr
+++ b/tests/ui/nll/issue-54189.stderr
@@ -4,6 +4,6 @@ error[E0582]: binding for associated type `Output` references lifetime `'r`, whi
 LL | fn bug() -> impl for <'r> Fn() -> &'r () { || { &() } }
    |                                   ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0582`.
diff --git a/tests/ui/nll/issue-54302.stderr b/tests/ui/nll/issue-54302.stderr
index 26c46571f9c..269739af602 100644
--- a/tests/ui/nll/issue-54302.stderr
+++ b/tests/ui/nll/issue-54302.stderr
@@ -7,5 +7,5 @@ LL |     assert_deserialize_owned::<&'static str>();
    = note: `&'static str` must implement `Deserialize<'0>`, for any lifetime `'0`...
    = note: ...but `&str` actually implements `Deserialize<'1>`, for some specific lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-54382-use-span-of-tail-of-block.stderr b/tests/ui/nll/issue-54382-use-span-of-tail-of-block.stderr
index 4a32c777a86..4f113945818 100644
--- a/tests/ui/nll/issue-54382-use-span-of-tail-of-block.stderr
+++ b/tests/ui/nll/issue-54382-use-span-of-tail-of-block.stderr
@@ -21,6 +21,6 @@ help: consider adding semicolon after the expression so its temporaries are drop
 LL |             D("other").next(&_thing1);
    |                                      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-54556-niconii.stderr b/tests/ui/nll/issue-54556-niconii.stderr
index ad0a2d1e324..015d9e18212 100644
--- a/tests/ui/nll/issue-54556-niconii.stderr
+++ b/tests/ui/nll/issue-54556-niconii.stderr
@@ -21,6 +21,6 @@ help: consider adding semicolon after the expression so its temporaries are drop
 LL |     if let Ok(_) = counter.lock() { };
    |                                      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-54556-stephaneyfx.stderr b/tests/ui/nll/issue-54556-stephaneyfx.stderr
index 0dfea0fd748..2296407535b 100644
--- a/tests/ui/nll/issue-54556-stephaneyfx.stderr
+++ b/tests/ui/nll/issue-54556-stephaneyfx.stderr
@@ -21,6 +21,6 @@ help: for example, you could save the expression's value in a new local variable
 LL |     let x = rows.map(|row| row).next(); x
    |     +++++++                           +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-54556-temps-in-tail-diagnostic.stderr b/tests/ui/nll/issue-54556-temps-in-tail-diagnostic.stderr
index 4eae9fdcde0..b5bfdfd7f6a 100644
--- a/tests/ui/nll/issue-54556-temps-in-tail-diagnostic.stderr
+++ b/tests/ui/nll/issue-54556-temps-in-tail-diagnostic.stderr
@@ -20,6 +20,6 @@ help: consider adding semicolon after the expression so its temporaries are drop
 LL |         D(&_thing1).end();
    |                          +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-54556-wrap-it-up.stderr b/tests/ui/nll/issue-54556-wrap-it-up.stderr
index adc419ae515..59130332118 100644
--- a/tests/ui/nll/issue-54556-wrap-it-up.stderr
+++ b/tests/ui/nll/issue-54556-wrap-it-up.stderr
@@ -9,6 +9,6 @@ LL |     x = 1;
 LL | }
    | - borrow might be used here, when `foo` is dropped and runs the destructor for type `Foo<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/issue-54779-anon-static-lifetime.stderr b/tests/ui/nll/issue-54779-anon-static-lifetime.stderr
index 64ad7a21a3c..92298c6617f 100644
--- a/tests/ui/nll/issue-54779-anon-static-lifetime.stderr
+++ b/tests/ui/nll/issue-54779-anon-static-lifetime.stderr
@@ -7,5 +7,5 @@ LL |         cx: &dyn DebugContext,
 LL |         bar.debug_with(cx);
    |                        ^^ cast requires that `'1` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-54943.stderr b/tests/ui/nll/issue-54943.stderr
index 59be0f983b9..7ea73633683 100644
--- a/tests/ui/nll/issue-54943.stderr
+++ b/tests/ui/nll/issue-54943.stderr
@@ -7,5 +7,5 @@ LL | fn boo<'a>() {
 LL |     let x = foo::<&'a u32>();
    |             ^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-55394.stderr b/tests/ui/nll/issue-55394.stderr
index 24b8c84b4a9..69df9010264 100644
--- a/tests/ui/nll/issue-55394.stderr
+++ b/tests/ui/nll/issue-55394.stderr
@@ -8,5 +8,5 @@ LL |     fn new(bar: &mut Bar) -> Self {
 LL |         Foo { bar }
    |         ^^^^^^^^^^^ associated function was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-55401.stderr b/tests/ui/nll/issue-55401.stderr
index 4f797f26a1a..50167dd28f9 100644
--- a/tests/ui/nll/issue-55401.stderr
+++ b/tests/ui/nll/issue-55401.stderr
@@ -7,5 +7,5 @@ LL |     let (ref y, _z): (&'a u32, u32) = (&22, 44);
 LL |     *y
    |     ^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-55511.stderr b/tests/ui/nll/issue-55511.stderr
index ecb9ef0aef9..ac7cd54df71 100644
--- a/tests/ui/nll/issue-55511.stderr
+++ b/tests/ui/nll/issue-55511.stderr
@@ -12,6 +12,6 @@ LL |         <() as Foo<'static>>::C => { }
 LL | }
    | - `a` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-57265-return-type-wf-check.stderr b/tests/ui/nll/issue-57265-return-type-wf-check.stderr
index bb45575fa64..d6810fe0938 100644
--- a/tests/ui/nll/issue-57265-return-type-wf-check.stderr
+++ b/tests/ui/nll/issue-57265-return-type-wf-check.stderr
@@ -7,6 +7,6 @@ LL |     let (_, z) = foo(&"hello".to_string());
    |                  |    creates a temporary value which is freed while still in use
    |                  argument requires that borrow lasts for `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/nll/issue-57280-1-flipped.stderr b/tests/ui/nll/issue-57280-1-flipped.stderr
index 7a2135a2ade..81bff3ba0fb 100644
--- a/tests/ui/nll/issue-57280-1-flipped.stderr
+++ b/tests/ui/nll/issue-57280-1-flipped.stderr
@@ -7,5 +7,5 @@ LL |     match x {
 LL |         <() as Foo<'a>>::C => { }
    |         ^^^^^^^^^^^^^^^^^^ type annotation requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-57843.stderr b/tests/ui/nll/issue-57843.stderr
index 2ab49ec61cf..eed511460ca 100644
--- a/tests/ui/nll/issue-57843.stderr
+++ b/tests/ui/nll/issue-57843.stderr
@@ -7,5 +7,5 @@ LL |     Foo(Box::new(|_| ()));
    = note: closure with signature `fn(&'2 bool)` must implement `FnOnce<(&'1 bool,)>`, for any lifetime `'1`...
    = note: ...but it actually implements `FnOnce<(&'2 bool,)>`, for some specific lifetime `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-61424.stderr b/tests/ui/nll/issue-61424.stderr
index 6de6b7f3abd..8dc66cbaef8 100644
--- a/tests/ui/nll/issue-61424.stderr
+++ b/tests/ui/nll/issue-61424.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unused_mut)]
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-67007-escaping-data.stderr b/tests/ui/nll/issue-67007-escaping-data.stderr
index ac9c59bf7f2..eb7b57c7e99 100644
--- a/tests/ui/nll/issue-67007-escaping-data.stderr
+++ b/tests/ui/nll/issue-67007-escaping-data.stderr
@@ -10,5 +10,5 @@ LL |         let other = self.use_fcx(fcx);
    |
    = help: consider adding the following bound: `'a: 'tcx`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-68550.stderr b/tests/ui/nll/issue-68550.stderr
index 851e3628748..323ba7b8441 100644
--- a/tests/ui/nll/issue-68550.stderr
+++ b/tests/ui/nll/issue-68550.stderr
@@ -13,6 +13,6 @@ LL |     let _: &'a A = &x;
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-69114-static-ty.stderr b/tests/ui/nll/issue-69114-static-ty.stderr
index 9215e850f7d..a77ae851621 100644
--- a/tests/ui/nll/issue-69114-static-ty.stderr
+++ b/tests/ui/nll/issue-69114-static-ty.stderr
@@ -12,6 +12,6 @@ LL |
 LL | }
    | - `n` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/issue-73159-rpit-static.stderr b/tests/ui/nll/issue-73159-rpit-static.stderr
index 4d3a9015316..472db30fbeb 100644
--- a/tests/ui/nll/issue-73159-rpit-static.stderr
+++ b/tests/ui/nll/issue-73159-rpit-static.stderr
@@ -8,6 +8,6 @@ LL |     fn make_it(&self) -> impl Iterator<Item = u8> {
 LL |         self.0.iter().copied()
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/nll/issue-75777.stderr b/tests/ui/nll/issue-75777.stderr
index 370cd72fd55..402c411a638 100644
--- a/tests/ui/nll/issue-75777.stderr
+++ b/tests/ui/nll/issue-75777.stderr
@@ -7,5 +7,5 @@ LL |     let fut: BoxFuture<'a, A> = Box::pin(future::ready(v));
 LL |     Box::new(move |_| fut)
    |     ^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-95272.stderr b/tests/ui/nll/issue-95272.stderr
index 03edbc3a670..0453ef8e53e 100644
--- a/tests/ui/nll/issue-95272.stderr
+++ b/tests/ui/nll/issue-95272.stderr
@@ -13,5 +13,5 @@ LL |     let f = check;
    = note: the function `check` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/issue-98693.stderr b/tests/ui/nll/issue-98693.stderr
index a3d87d74a8e..b5e281538f9 100644
--- a/tests/ui/nll/issue-98693.stderr
+++ b/tests/ui/nll/issue-98693.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn test<T: 'static>() {
    |          +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/nll/loan_ends_mid_block_pair.stderr b/tests/ui/nll/loan_ends_mid_block_pair.stderr
index 58e378ab021..5f8e9d5c6ac 100644
--- a/tests/ui/nll/loan_ends_mid_block_pair.stderr
+++ b/tests/ui/nll/loan_ends_mid_block_pair.stderr
@@ -10,6 +10,6 @@ LL |     data.0 = 'e';
 LL |     capitalize(c);
    |                - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/match-cfg-fake-edges2.stderr b/tests/ui/nll/match-cfg-fake-edges2.stderr
index 36f2cd0b85d..639cba1406a 100644
--- a/tests/ui/nll/match-cfg-fake-edges2.stderr
+++ b/tests/ui/nll/match-cfg-fake-edges2.stderr
@@ -10,6 +10,6 @@ LL |     match y {
 LL |             r;
    |             - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/nll/maybe-initialized-drop-implicit-fragment-drop.stderr b/tests/ui/nll/maybe-initialized-drop-implicit-fragment-drop.stderr
index 55646b9dca9..56c1fce0650 100644
--- a/tests/ui/nll/maybe-initialized-drop-implicit-fragment-drop.stderr
+++ b/tests/ui/nll/maybe-initialized-drop-implicit-fragment-drop.stderr
@@ -10,6 +10,6 @@ LL |     // FIXME ^ Should not error in the future with implicit dtors, only man
 LL | }
    | - borrow might be used here, when `foo` is dropped and runs the destructor for type `Foo<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/maybe-initialized-drop-with-fragment.stderr b/tests/ui/nll/maybe-initialized-drop-with-fragment.stderr
index c89f94a7894..e6f275a241b 100644
--- a/tests/ui/nll/maybe-initialized-drop-with-fragment.stderr
+++ b/tests/ui/nll/maybe-initialized-drop-with-fragment.stderr
@@ -9,6 +9,6 @@ LL |     x = 1;
 LL | }
    | - borrow might be used here, when `foo` is dropped and runs the destructor for type `Foo<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/maybe-initialized-drop-with-uninitialized-fragments.stderr b/tests/ui/nll/maybe-initialized-drop-with-uninitialized-fragments.stderr
index 90db13bc578..610a0d6e9cc 100644
--- a/tests/ui/nll/maybe-initialized-drop-with-uninitialized-fragments.stderr
+++ b/tests/ui/nll/maybe-initialized-drop-with-uninitialized-fragments.stderr
@@ -10,6 +10,6 @@ LL |     // FIXME ^ This currently errors and it should not.
 LL | }
    | - borrow might be used here, when `foo` is dropped and runs the destructor for type `Foo<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/maybe-initialized-drop.stderr b/tests/ui/nll/maybe-initialized-drop.stderr
index 15a53a09af8..7f231c48822 100644
--- a/tests/ui/nll/maybe-initialized-drop.stderr
+++ b/tests/ui/nll/maybe-initialized-drop.stderr
@@ -8,6 +8,6 @@ LL |     x = 1;
 LL | }
    | - borrow might be used here, when `wrap` is dropped and runs the `Drop` code for type `Wrap`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/nll/mir_check_cast_closure.stderr b/tests/ui/nll/mir_check_cast_closure.stderr
index 72d99aad99e..fcb19189141 100644
--- a/tests/ui/nll/mir_check_cast_closure.stderr
+++ b/tests/ui/nll/mir_check_cast_closure.stderr
@@ -11,5 +11,5 @@ LL |     g
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/mir_check_cast_reify.stderr b/tests/ui/nll/mir_check_cast_reify.stderr
index 9be2670fec7..9500e474bc6 100644
--- a/tests/ui/nll/mir_check_cast_reify.stderr
+++ b/tests/ui/nll/mir_check_cast_reify.stderr
@@ -7,5 +7,5 @@ LL | fn bar<'a>(x: &'a u32) -> &'static u32 {
 LL |     f(x)
    |     ^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/mir_check_cast_unsafe_fn.stderr b/tests/ui/nll/mir_check_cast_unsafe_fn.stderr
index 321d17ba6b1..94483e94a85 100644
--- a/tests/ui/nll/mir_check_cast_unsafe_fn.stderr
+++ b/tests/ui/nll/mir_check_cast_unsafe_fn.stderr
@@ -7,5 +7,5 @@ LL | fn bar<'a>(input: &'a u32, f: fn(&'a u32) -> &'a u32) -> &'static u32 {
 LL |     unsafe { g(input) }
    |              ^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/mir_check_cast_unsize.stderr b/tests/ui/nll/mir_check_cast_unsize.stderr
index 1cd2579e4c4..84958eae5b4 100644
--- a/tests/ui/nll/mir_check_cast_unsize.stderr
+++ b/tests/ui/nll/mir_check_cast_unsize.stderr
@@ -11,5 +11,5 @@ help: to declare that the trait object captures data from argument `x`, you can
 LL | fn bar<'a>(x: &'a u32) -> &'static dyn Debug + 'a {
    |                                              ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/move-subpaths-moves-root.stderr b/tests/ui/nll/move-subpaths-moves-root.stderr
index ae9287f9226..7a7c7801643 100644
--- a/tests/ui/nll/move-subpaths-moves-root.stderr
+++ b/tests/ui/nll/move-subpaths-moves-root.stderr
@@ -8,6 +8,6 @@ LL |     drop(x);
    |
    = note: partial move occurs because `x.0` has type `Vec<i32>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/nll/normalization-bounds-error.stderr b/tests/ui/nll/normalization-bounds-error.stderr
index 0fc3670d6c5..c6f3f2fd018 100644
--- a/tests/ui/nll/normalization-bounds-error.stderr
+++ b/tests/ui/nll/normalization-bounds-error.stderr
@@ -22,6 +22,6 @@ LL | fn visit_seq<'d, 'a: 'd>() -> <&'a () as Visitor<'d>>::Value {}
    = note: expected `Visitor<'d>`
               found `Visitor<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0495`.
diff --git a/tests/ui/nll/polonius/subset-relations.stderr b/tests/ui/nll/polonius/subset-relations.stderr
index 6df5563eabb..9deca6449a8 100644
--- a/tests/ui/nll/polonius/subset-relations.stderr
+++ b/tests/ui/nll/polonius/subset-relations.stderr
@@ -10,5 +10,5 @@ LL |     y
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/promoted-bounds.stderr b/tests/ui/nll/promoted-bounds.stderr
index d111256b845..73fda380522 100644
--- a/tests/ui/nll/promoted-bounds.stderr
+++ b/tests/ui/nll/promoted-bounds.stderr
@@ -11,6 +11,6 @@ LL |         let b = &l;
 LL |     };
    |     - `l` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/promoted-closure-pair.stderr b/tests/ui/nll/promoted-closure-pair.stderr
index 000bdf85804..ee00b7ba51f 100644
--- a/tests/ui/nll/promoted-closure-pair.stderr
+++ b/tests/ui/nll/promoted-closure-pair.stderr
@@ -7,6 +7,6 @@ LL |     p.1(&z)
    |     |   `z` is borrowed here
    |     returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/reference-carried-through-struct-field.stderr b/tests/ui/nll/reference-carried-through-struct-field.stderr
index 5672b9cd7e9..b26f73fc70a 100644
--- a/tests/ui/nll/reference-carried-through-struct-field.stderr
+++ b/tests/ui/nll/reference-carried-through-struct-field.stderr
@@ -8,6 +8,6 @@ LL |     x += 1;
 LL |     *wrapper.w += 1;
    |     --------------- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/nll/region-ends-after-if-condition.stderr b/tests/ui/nll/region-ends-after-if-condition.stderr
index c03e3857906..b7c37caa20f 100644
--- a/tests/ui/nll/region-ends-after-if-condition.stderr
+++ b/tests/ui/nll/region-ends-after-if-condition.stderr
@@ -10,6 +10,6 @@ LL |         my_struct.field.push_str("Hello, world!");
 LL |     drop(value);
    |          ----- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/nll/relate_tys/fn-subtype.stderr b/tests/ui/nll/relate_tys/fn-subtype.stderr
index 21073647ea7..0e3ab41da87 100644
--- a/tests/ui/nll/relate_tys/fn-subtype.stderr
+++ b/tests/ui/nll/relate_tys/fn-subtype.stderr
@@ -7,6 +7,6 @@ LL |     let y: for<'a> fn(&'a ()) = x;
    = note: expected fn pointer `for<'a> fn(&'a ())`
               found fn pointer `fn(&())`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/nll/relate_tys/opaque-hrtb.stderr b/tests/ui/nll/relate_tys/opaque-hrtb.stderr
index d75ec2b57d4..d48745d2d28 100644
--- a/tests/ui/nll/relate_tys/opaque-hrtb.stderr
+++ b/tests/ui/nll/relate_tys/opaque-hrtb.stderr
@@ -7,5 +7,5 @@ LL |     bar()
    = note: `impl MyTrait<&'2 str>` must implement `MyTrait<&'1 str>`, for any lifetime `'1`...
    = note: ...but it actually implements `MyTrait<&'2 str>`, for some specific lifetime `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/relate_tys/trait-hrtb.stderr b/tests/ui/nll/relate_tys/trait-hrtb.stderr
index aa1927711b3..7f7b94c0b30 100644
--- a/tests/ui/nll/relate_tys/trait-hrtb.stderr
+++ b/tests/ui/nll/relate_tys/trait-hrtb.stderr
@@ -7,6 +7,6 @@ LL |     let y: Box<dyn for<'a> Foo<'a>> = x;
    = note: expected trait object `dyn for<'a> Foo<'a>`
               found trait object `dyn Foo<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/nll/relate_tys/universe-violation.stderr b/tests/ui/nll/relate_tys/universe-violation.stderr
index fe801b42c0a..b585eee0769 100644
--- a/tests/ui/nll/relate_tys/universe-violation.stderr
+++ b/tests/ui/nll/relate_tys/universe-violation.stderr
@@ -7,6 +7,6 @@ LL |     let b: fn(&u32) -> &u32 = a;
    = note: expected fn pointer `for<'a> fn(&'a u32) -> &'a u32`
               found fn pointer `fn(&u32) -> &u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/nll/relate_tys/var-appears-twice.stderr b/tests/ui/nll/relate_tys/var-appears-twice.stderr
index ff6ea598ff4..3f9a6cec0d2 100644
--- a/tests/ui/nll/relate_tys/var-appears-twice.stderr
+++ b/tests/ui/nll/relate_tys/var-appears-twice.stderr
@@ -12,6 +12,6 @@ LL |     let x: DoubleCell<_> = make_cell(&b);
 LL | }
    | - `b` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/return-ref-mut-issue-46557.stderr b/tests/ui/nll/return-ref-mut-issue-46557.stderr
index 720440a0ae5..358830fd516 100644
--- a/tests/ui/nll/return-ref-mut-issue-46557.stderr
+++ b/tests/ui/nll/return-ref-mut-issue-46557.stderr
@@ -6,6 +6,6 @@ LL |     let ref mut x = 1234543;
 LL |     x
    |     ^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/nll/return_from_loop.stderr b/tests/ui/nll/return_from_loop.stderr
index efd56ea2dd5..9fe681680c6 100644
--- a/tests/ui/nll/return_from_loop.stderr
+++ b/tests/ui/nll/return_from_loop.stderr
@@ -10,6 +10,6 @@ LL |
 LL |         value.len();
    |         ----- first borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/nll/snocat-regression.stderr b/tests/ui/nll/snocat-regression.stderr
index 0868984734d..135b6951537 100644
--- a/tests/ui/nll/snocat-regression.stderr
+++ b/tests/ui/nll/snocat-regression.stderr
@@ -10,5 +10,5 @@ LL | |         let _x = link;
 LL | |     };
    | |_____^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/trait-associated-constant.stderr b/tests/ui/nll/trait-associated-constant.stderr
index cf1c52ba7cc..f6277508eeb 100644
--- a/tests/ui/nll/trait-associated-constant.stderr
+++ b/tests/ui/nll/trait-associated-constant.stderr
@@ -17,6 +17,6 @@ note: ...does not necessarily outlive the lifetime `'b` as defined here
 LL | impl<'a: 'b, 'b, 'c> Anything<'a, 'b> for FailStruct {
    |              ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/nll/ty-outlives/impl-trait-captures.stderr b/tests/ui/nll/ty-outlives/impl-trait-captures.stderr
index 320f529624f..693c5b8b0a3 100644
--- a/tests/ui/nll/ty-outlives/impl-trait-captures.stderr
+++ b/tests/ui/nll/ty-outlives/impl-trait-captures.stderr
@@ -13,6 +13,6 @@ help: to declare that `Opaque(DefId(0:13 ~ impl_trait_captures[aeb9]::foo::{opaq
 LL | fn foo<'a, T>(x: &T) -> impl Foo<'a> + ReLateParam(DefId(0:8 ~ impl_trait_captures[aeb9]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[aeb9]::foo::'_), '_)) {
    |                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr b/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
index 6de023ffdd4..2aab03ee7b7 100644
--- a/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
+++ b/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn generic2<T: Iterator + 'static>(value: T) {
    |                         +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
index 1fa74f67ccd..f8ecc0c6826 100644
--- a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
+++ b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
@@ -9,6 +9,6 @@ LL |     bar::<T::Output>()
    |
    = help: consider adding an explicit lifetime bound `<T as MyTrait<'_>>::Output: 'a`...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
index c8dbe4ebc6d..13ad665e261 100644
--- a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
+++ b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
@@ -9,6 +9,6 @@ LL |     bar::<<T as MyTrait<'a>>::Output>()
    |
    = help: consider adding an explicit lifetime bound `<T as MyTrait<'_>>::Output: 'a`...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr b/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
index f78708dc48d..b4136be36d3 100644
--- a/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
+++ b/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL |     T: MyTrait<'a> + 'a,
    |                    ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr b/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
index 0048eef6779..acbcb9f0b70 100644
--- a/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
@@ -56,6 +56,6 @@ help: consider adding an explicit lifetime bound
 LL | fn generic_fail<'a, T: 'a>(cell: Cell<&'a ()>, value: T) {
    |                      ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr b/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
index 73f01ff1519..c884909c942 100644
--- a/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
@@ -11,6 +11,6 @@ help: consider adding an explicit lifetime bound
 LL | fn region_static<'a, T: 'a>(cell: Cell<&'a usize>, t: T) {
    |                       ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/nll/unused-mut-issue-50343.stderr b/tests/ui/nll/unused-mut-issue-50343.stderr
index cb02d76205c..582ca17cccc 100644
--- a/tests/ui/nll/unused-mut-issue-50343.stderr
+++ b/tests/ui/nll/unused-mut-issue-50343.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unused_mut)]
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/ascribed-type-wf.stderr b/tests/ui/nll/user-annotations/ascribed-type-wf.stderr
index 91e7c6b8ecf..2bd00a51fe2 100644
--- a/tests/ui/nll/user-annotations/ascribed-type-wf.stderr
+++ b/tests/ui/nll/user-annotations/ascribed-type-wf.stderr
@@ -6,5 +6,5 @@ LL | fn extend<'a>() {
 LL |     None::<<&'a () as Trait>::Ty>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/cast_static_lifetime.stderr b/tests/ui/nll/user-annotations/cast_static_lifetime.stderr
index 3b9363c41f2..35eec233ed5 100644
--- a/tests/ui/nll/user-annotations/cast_static_lifetime.stderr
+++ b/tests/ui/nll/user-annotations/cast_static_lifetime.stderr
@@ -11,6 +11,6 @@ LL |     let y: &u32 = (&x) as &'static u32;
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/user-annotations/constant-in-expr-inherent-1.stderr b/tests/ui/nll/user-annotations/constant-in-expr-inherent-1.stderr
index c39301588ac..cf699a3e476 100644
--- a/tests/ui/nll/user-annotations/constant-in-expr-inherent-1.stderr
+++ b/tests/ui/nll/user-annotations/constant-in-expr-inherent-1.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a>(_: &'a u32) -> &'static u32 {
 LL |     <Foo<'a>>::C
    |     ^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/constant-in-expr-normalize.stderr b/tests/ui/nll/user-annotations/constant-in-expr-normalize.stderr
index 541a2cfaf29..ee06ac7407a 100644
--- a/tests/ui/nll/user-annotations/constant-in-expr-normalize.stderr
+++ b/tests/ui/nll/user-annotations/constant-in-expr-normalize.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a>(_: &'a u32) -> &'static u32 {
 LL |     <() as Foo<'a>>::C
    |     ^^^^^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/constant-in-expr-trait-item-1.stderr b/tests/ui/nll/user-annotations/constant-in-expr-trait-item-1.stderr
index ea0fcb6d634..02b17a3856a 100644
--- a/tests/ui/nll/user-annotations/constant-in-expr-trait-item-1.stderr
+++ b/tests/ui/nll/user-annotations/constant-in-expr-trait-item-1.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a>(_: &'a u32) -> &'static u32 {
 LL |     <() as Foo<'a>>::C
    |     ^^^^^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/constant-in-expr-trait-item-2.stderr b/tests/ui/nll/user-annotations/constant-in-expr-trait-item-2.stderr
index ff549f1d88b..06e4848e71c 100644
--- a/tests/ui/nll/user-annotations/constant-in-expr-trait-item-2.stderr
+++ b/tests/ui/nll/user-annotations/constant-in-expr-trait-item-2.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a, T: Foo<'a>>() -> &'static u32 {
 LL |     <T as Foo<'a>>::C
    |     ^^^^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/constant-in-expr-trait-item-3.stderr b/tests/ui/nll/user-annotations/constant-in-expr-trait-item-3.stderr
index 7f160d8e398..754e09fe326 100644
--- a/tests/ui/nll/user-annotations/constant-in-expr-trait-item-3.stderr
+++ b/tests/ui/nll/user-annotations/constant-in-expr-trait-item-3.stderr
@@ -6,5 +6,5 @@ LL | fn foo<'a, T: Foo<'a>>() -> &'static u32 {
 LL |     T::C
    |     ^^^^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/dump-adt-brace-struct.stderr b/tests/ui/nll/user-annotations/dump-adt-brace-struct.stderr
index 7809b2470fe..0cabc02c6b5 100644
--- a/tests/ui/nll/user-annotations/dump-adt-brace-struct.stderr
+++ b/tests/ui/nll/user-annotations/dump-adt-brace-struct.stderr
@@ -4,5 +4,5 @@ error: user args: UserArgs { args: [&ReStatic u32], user_self_ty: None }
 LL |     SomeStruct::<&'static u32> { t: &22 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/inherent-associated-constants.stderr b/tests/ui/nll/user-annotations/inherent-associated-constants.stderr
index ffbfc40f537..c1030152814 100644
--- a/tests/ui/nll/user-annotations/inherent-associated-constants.stderr
+++ b/tests/ui/nll/user-annotations/inherent-associated-constants.stderr
@@ -6,5 +6,5 @@ LL | fn non_wf_associated_const<'a>(x: i32) {
 LL |     A::<'a>::IC;
    |     ^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/method-ufcs-inherent-1.stderr b/tests/ui/nll/user-annotations/method-ufcs-inherent-1.stderr
index fb26b8d09e1..2d2397456c9 100644
--- a/tests/ui/nll/user-annotations/method-ufcs-inherent-1.stderr
+++ b/tests/ui/nll/user-annotations/method-ufcs-inherent-1.stderr
@@ -14,6 +14,6 @@ LL |
 LL | }
    | - `v` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/user-annotations/method-ufcs-inherent-3.stderr b/tests/ui/nll/user-annotations/method-ufcs-inherent-3.stderr
index 69dd1d1aaae..99d57902d6a 100644
--- a/tests/ui/nll/user-annotations/method-ufcs-inherent-3.stderr
+++ b/tests/ui/nll/user-annotations/method-ufcs-inherent-3.stderr
@@ -14,6 +14,6 @@ LL |
 LL | }
    | - `v` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/user-annotations/promoted-annotation.stderr b/tests/ui/nll/user-annotations/promoted-annotation.stderr
index 132a00ba415..ca99e531870 100644
--- a/tests/ui/nll/user-annotations/promoted-annotation.stderr
+++ b/tests/ui/nll/user-annotations/promoted-annotation.stderr
@@ -13,6 +13,6 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/user-annotations/type_ascription_static_lifetime.stderr b/tests/ui/nll/user-annotations/type_ascription_static_lifetime.stderr
index 766877f8835..3e2706309b3 100644
--- a/tests/ui/nll/user-annotations/type_ascription_static_lifetime.stderr
+++ b/tests/ui/nll/user-annotations/type_ascription_static_lifetime.stderr
@@ -11,6 +11,6 @@ LL |     let y: &u32 = type_ascribe!(&x, &'static u32);
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/nll/user-annotations/wf-self-type.stderr b/tests/ui/nll/user-annotations/wf-self-type.stderr
index 1d3ae7cfbd7..dfc5410b744 100644
--- a/tests/ui/nll/user-annotations/wf-self-type.stderr
+++ b/tests/ui/nll/user-annotations/wf-self-type.stderr
@@ -10,5 +10,5 @@ LL |     Foo::xmute(u)
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/where_clauses_in_functions.stderr b/tests/ui/nll/where_clauses_in_functions.stderr
index afb25e3bc69..41d7e6237b4 100644
--- a/tests/ui/nll/where_clauses_in_functions.stderr
+++ b/tests/ui/nll/where_clauses_in_functions.stderr
@@ -10,5 +10,5 @@ LL |     foo(x, y)
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/where_clauses_in_structs.stderr b/tests/ui/nll/where_clauses_in_structs.stderr
index c46cfcb4134..4cc7e5ab1b4 100644
--- a/tests/ui/nll/where_clauses_in_structs.stderr
+++ b/tests/ui/nll/where_clauses_in_structs.stderr
@@ -13,5 +13,5 @@ LL |     Foo { x, y };
    = note: the struct `Cell<T>` is invariant over the parameter `T`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/no-capture-arc.stderr b/tests/ui/no-capture-arc.stderr
index 296e1fb3f26..38432c851c5 100644
--- a/tests/ui/no-capture-arc.stderr
+++ b/tests/ui/no-capture-arc.stderr
@@ -14,6 +14,6 @@ LL |     assert_eq!((*arc_v)[2], 3);
    |
    = note: borrow occurs due to deref coercion to `Vec<i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/no-link-unknown-crate.stderr b/tests/ui/no-link-unknown-crate.stderr
index 068c7139ed9..edc248db09e 100644
--- a/tests/ui/no-link-unknown-crate.stderr
+++ b/tests/ui/no-link-unknown-crate.stderr
@@ -4,6 +4,6 @@ error[E0463]: can't find crate for `doesnt_exist`
 LL | extern crate doesnt_exist;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ can't find crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0463`.
diff --git a/tests/ui/no-reuse-move-arc.stderr b/tests/ui/no-reuse-move-arc.stderr
index bcd481c33f3..cdeb6eadc17 100644
--- a/tests/ui/no-reuse-move-arc.stderr
+++ b/tests/ui/no-reuse-move-arc.stderr
@@ -14,6 +14,6 @@ LL |     assert_eq!((*arc_v)[2], 3);
    |
    = note: borrow occurs due to deref coercion to `Vec<i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/no-send-res-ports.stderr b/tests/ui/no-send-res-ports.stderr
index 33446e9d162..9c30261e5cb 100644
--- a/tests/ui/no-send-res-ports.stderr
+++ b/tests/ui/no-send-res-ports.stderr
@@ -32,6 +32,6 @@ LL |     thread::spawn(move|| {
 note: required by a bound in `spawn`
   --> $SRC_DIR/std/src/thread/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/no_crate_type.stderr b/tests/ui/no_crate_type.stderr
index 93da7c3e0dd..85d8f87afa6 100644
--- a/tests/ui/no_crate_type.stderr
+++ b/tests/ui/no_crate_type.stderr
@@ -4,5 +4,5 @@ error: malformed `crate_type` attribute input
 LL | #![crate_type]
    | ^^^^^^^^^^^^^^ help: must be of the form: `#![crate_type = "bin|lib|..."]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/no_send-enum.stderr b/tests/ui/no_send-enum.stderr
index b5a14b551dc..3b66c7db545 100644
--- a/tests/ui/no_send-enum.stderr
+++ b/tests/ui/no_send-enum.stderr
@@ -18,6 +18,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Send>(_: T) {}
    |           ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/no_send-rc.stderr b/tests/ui/no_send-rc.stderr
index ce25da559da..3534167870b 100644
--- a/tests/ui/no_send-rc.stderr
+++ b/tests/ui/no_send-rc.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Send>(_: T) {}
    |           ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/no_share-enum.stderr b/tests/ui/no_share-enum.stderr
index 5b453e0da3b..89939216d5b 100644
--- a/tests/ui/no_share-enum.stderr
+++ b/tests/ui/no_share-enum.stderr
@@ -18,6 +18,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Sync>(_: T) {}
    |           ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/no_share-struct.stderr b/tests/ui/no_share-struct.stderr
index 9ce3a318f1d..9c7a921b8d8 100644
--- a/tests/ui/no_share-struct.stderr
+++ b/tests/ui/no_share-struct.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Sync>(_: T) {}
    |           ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/noexporttypeexe.stderr b/tests/ui/noexporttypeexe.stderr
index bf88ceaa5d2..59759b696c7 100644
--- a/tests/ui/noexporttypeexe.stderr
+++ b/tests/ui/noexporttypeexe.stderr
@@ -13,6 +13,6 @@ help: consider using `Option::expect` to unwrap the `Option<isize>` value, panic
 LL |   let x: isize = noexporttypelib::foo().expect("REASON");
    |                                        +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/non-constant-expr-for-arr-len.stderr b/tests/ui/non-constant-expr-for-arr-len.stderr
index d684b8eaabd..c9f977fbaa4 100644
--- a/tests/ui/non-constant-expr-for-arr-len.stderr
+++ b/tests/ui/non-constant-expr-for-arr-len.stderr
@@ -6,6 +6,6 @@ LL |     fn bar(n: usize) {
 LL |         let _x = [0; n];
    |                      ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/non-copyable-void.stderr b/tests/ui/non-copyable-void.stderr
index 99af04e7cd9..bef1e1077eb 100644
--- a/tests/ui/non-copyable-void.stderr
+++ b/tests/ui/non-copyable-void.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `clone` found for enum `c_void` in the current sco
 LL |         let _z = (*y).clone();
    |                       ^^^^^ method not found in `c_void`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/noncopyable-class.stderr b/tests/ui/noncopyable-class.stderr
index 0c696163a26..b8f7276c898 100644
--- a/tests/ui/noncopyable-class.stderr
+++ b/tests/ui/noncopyable-class.stderr
@@ -11,6 +11,6 @@ LL |     let _y = x.clone();
    = note: the following trait defines an item `clone`, perhaps you need to implement it:
            candidate #1: `Clone`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/nonscalar-cast.stderr b/tests/ui/nonscalar-cast.stderr
index 2a703712187..01b4a9a7ce0 100644
--- a/tests/ui/nonscalar-cast.stderr
+++ b/tests/ui/nonscalar-cast.stderr
@@ -6,6 +6,6 @@ LL |     println!("{}", Foo { x: 1 } as isize);
    |
    = note: an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/not-clone-closure.stderr b/tests/ui/not-clone-closure.stderr
index 17cf938d170..783c165eeb2 100644
--- a/tests/ui/not-clone-closure.stderr
+++ b/tests/ui/not-clone-closure.stderr
@@ -18,6 +18,6 @@ LL + #[derive(Clone)]
 LL | struct S(i32);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/not-copy-closure.stderr b/tests/ui/not-copy-closure.stderr
index 93e011ccec4..50e25a24d81 100644
--- a/tests/ui/not-copy-closure.stderr
+++ b/tests/ui/not-copy-closure.stderr
@@ -16,6 +16,6 @@ help: consider mutably borrowing `hello`
 LL |     let b = &mut hello;
    |             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/not-panic/not-panic-safe-5.stderr b/tests/ui/not-panic/not-panic-safe-5.stderr
index cb78370b48a..fbbd81d6d4c 100644
--- a/tests/ui/not-panic/not-panic-safe-5.stderr
+++ b/tests/ui/not-panic/not-panic-safe-5.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `assert`
 LL | fn assert<T: UnwindSafe + ?Sized>() {}
    |              ^^^^^^^^^^ required by this bound in `assert`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/not-panic/not-panic-safe.stderr b/tests/ui/not-panic/not-panic-safe.stderr
index 37a6aee3906..cd792eff926 100644
--- a/tests/ui/not-panic/not-panic-safe.stderr
+++ b/tests/ui/not-panic/not-panic-safe.stderr
@@ -17,6 +17,6 @@ LL -     assert::<&mut &mut &i32>();
 LL +     assert::<&i32>();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/numbers-arithmetic/overflowing-lsh-1.stderr b/tests/ui/numbers-arithmetic/overflowing-lsh-1.stderr
index 434c9d5b43d..5d2c4a6c8e2 100644
--- a/tests/ui/numbers-arithmetic/overflowing-lsh-1.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-lsh-1.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-lsh-2.stderr b/tests/ui/numbers-arithmetic/overflowing-lsh-2.stderr
index c3b44e5a043..8ac72aefe0d 100644
--- a/tests/ui/numbers-arithmetic/overflowing-lsh-2.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-lsh-2.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-lsh-3.stderr b/tests/ui/numbers-arithmetic/overflowing-lsh-3.stderr
index 9d6479bd7c7..43d541b0304 100644
--- a/tests/ui/numbers-arithmetic/overflowing-lsh-3.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-lsh-3.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-lsh-4.stderr b/tests/ui/numbers-arithmetic/overflowing-lsh-4.stderr
index 2bb5b6a6d6e..00a3581069f 100644
--- a/tests/ui/numbers-arithmetic/overflowing-lsh-4.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-lsh-4.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-rsh-1.stderr b/tests/ui/numbers-arithmetic/overflowing-rsh-1.stderr
index b2b3114d1b4..62763e9e1df 100644
--- a/tests/ui/numbers-arithmetic/overflowing-rsh-1.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-rsh-1.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-rsh-2.stderr b/tests/ui/numbers-arithmetic/overflowing-rsh-2.stderr
index ad18c3bb7f4..519e62fef7d 100644
--- a/tests/ui/numbers-arithmetic/overflowing-rsh-2.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-rsh-2.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-rsh-3.stderr b/tests/ui/numbers-arithmetic/overflowing-rsh-3.stderr
index 37d02e09dec..de24ea1fcde 100644
--- a/tests/ui/numbers-arithmetic/overflowing-rsh-3.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-rsh-3.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-rsh-4.stderr b/tests/ui/numbers-arithmetic/overflowing-rsh-4.stderr
index 692602c0719..47588012fb6 100644
--- a/tests/ui/numbers-arithmetic/overflowing-rsh-4.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-rsh-4.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-rsh-5.stderr b/tests/ui/numbers-arithmetic/overflowing-rsh-5.stderr
index e3b5859df90..e9a1572d3cc 100644
--- a/tests/ui/numbers-arithmetic/overflowing-rsh-5.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-rsh-5.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numbers-arithmetic/overflowing-rsh-6.stderr b/tests/ui/numbers-arithmetic/overflowing-rsh-6.stderr
index a3475c04c28..005f7378226 100644
--- a/tests/ui/numbers-arithmetic/overflowing-rsh-6.stderr
+++ b/tests/ui/numbers-arithmetic/overflowing-rsh-6.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(arithmetic_overflow)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/numeric/len.stderr b/tests/ui/numeric/len.stderr
index 55a61b5e443..7b20d35c876 100644
--- a/tests/ui/numeric/len.stderr
+++ b/tests/ui/numeric/len.stderr
@@ -16,6 +16,6 @@ help: you can convert a `usize` to a `u32` and panic if the converted value does
 LL |     test(array.len().try_into().unwrap());
    |                     ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic1.stderr b/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic1.stderr
index f06a9da1dee..8d44b4de55a 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic1.stderr
+++ b/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic1.stderr
@@ -4,6 +4,6 @@ error[E0228]: the lifetime bound for this object type cannot be deduced from con
 LL | fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar> { &() }
    |                                                  ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0228`.
diff --git a/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic2.stderr b/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic2.stderr
index 51d8450af76..0846dd60723 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic2.stderr
+++ b/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic2.stderr
@@ -4,6 +4,6 @@ error[E0228]: the lifetime bound for this object type cannot be deduced from con
 LL | fn bar<'a>(x: &'a str) -> &'a dyn Foo<'a, Item = dyn Bar> { &() }
    |                                                  ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0228`.
diff --git a/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic3.stderr b/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic3.stderr
index f721bf39419..688f8af0822 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic3.stderr
+++ b/tests/ui/object-lifetime/object-lifetime-default-dyn-binding-nonstatic3.stderr
@@ -4,6 +4,6 @@ error[E0228]: the lifetime bound for this object type cannot be deduced from con
 LL | fn bar(x: &str) -> &dyn Foo<Item = dyn Bar> { &() }
    |                                    ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0228`.
diff --git a/tests/ui/object-lifetime/object-lifetime-default-elision.stderr b/tests/ui/object-lifetime/object-lifetime-default-elision.stderr
index 61e96f59fed..b5995687927 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-elision.stderr
+++ b/tests/ui/object-lifetime/object-lifetime-default-elision.stderr
@@ -11,5 +11,5 @@ LL |     ss
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box-error.stderr b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box-error.stderr
index 7d6f9f39d13..b49e506a14d 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box-error.stderr
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box-error.stderr
@@ -6,5 +6,5 @@ LL | fn c<'a>(t: &'a Box<dyn Test+'a>, mut ss: SomeStruct<'a>) {
 LL |     ss.t = t;
    |     ^^^^^^^^ assignment requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct-error.stderr b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct-error.stderr
index 2bc8e097859..9e2422fdc77 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct-error.stderr
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct-error.stderr
@@ -6,5 +6,5 @@ LL | fn c<'a>(t: &'a MyBox<dyn Test+'a>, mut ss: SomeStruct<'a>) {
 LL |     ss.t = t;
    |     ^^^^^^^^ assignment requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/object-safety/assoc_type_bounds_implicit_sized.stderr b/tests/ui/object-safety/assoc_type_bounds_implicit_sized.stderr
index 110e7150733..cd2aa9fdbe3 100644
--- a/tests/ui/object-safety/assoc_type_bounds_implicit_sized.stderr
+++ b/tests/ui/object-safety/assoc_type_bounds_implicit_sized.stderr
@@ -15,6 +15,6 @@ help: consider relaxing the implicit `Sized` restriction
 LL |     type Item: ?Sized;
    |              ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/object-safety/issue-102762.stderr b/tests/ui/object-safety/issue-102762.stderr
index 5041ebe7760..2215ec677c5 100644
--- a/tests/ui/object-safety/issue-102762.stderr
+++ b/tests/ui/object-safety/issue-102762.stderr
@@ -15,6 +15,6 @@ LL | pub trait Fetcher: Send + Sync {
 LL |     fn get<'a>(self: &'a Box<Self>) -> Pin<Box<dyn Future<Output = Vec<u8>> + 'a>>
    |                      ^^^^^^^^^^^^^ ...because method `get`'s `self` parameter cannot be dispatched on
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-associated-consts.curr.stderr b/tests/ui/object-safety/object-safety-associated-consts.curr.stderr
index 5f94c9284ea..462d3d95f13 100644
--- a/tests/ui/object-safety/object-safety-associated-consts.curr.stderr
+++ b/tests/ui/object-safety/object-safety-associated-consts.curr.stderr
@@ -13,6 +13,6 @@ LL |     const X: usize;
    |           ^ ...because it contains this associated `const`
    = help: consider moving `X` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-associated-consts.object_safe_for_dispatch.stderr b/tests/ui/object-safety/object-safety-associated-consts.object_safe_for_dispatch.stderr
index db3e0885a85..d0c78f9cd69 100644
--- a/tests/ui/object-safety/object-safety-associated-consts.object_safe_for_dispatch.stderr
+++ b/tests/ui/object-safety/object-safety-associated-consts.object_safe_for_dispatch.stderr
@@ -14,6 +14,6 @@ LL |     const X: usize;
    = help: consider moving `X` to another trait
    = note: required for the cast from `&T` to `&dyn Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-bounds.stderr b/tests/ui/object-safety/object-safety-bounds.stderr
index 29ffb544842..bf3c055f4e3 100644
--- a/tests/ui/object-safety/object-safety-bounds.stderr
+++ b/tests/ui/object-safety/object-safety-bounds.stderr
@@ -12,6 +12,6 @@ LL | trait X {
 LL |     type U: PartialEq<Self>;
    |             ^^^^^^^^^^^^^^^ ...because it uses `Self` as a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-by-value-self-use.stderr b/tests/ui/object-safety/object-safety-by-value-self-use.stderr
index 17f4cb4d4a8..1701f6059a8 100644
--- a/tests/ui/object-safety/object-safety-by-value-self-use.stderr
+++ b/tests/ui/object-safety/object-safety-by-value-self-use.stderr
@@ -4,6 +4,6 @@ error[E0161]: cannot move a value of type `dyn Bar`
 LL |     t.bar()
    |     ^ the size of `dyn Bar` cannot be statically determined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0161`.
diff --git a/tests/ui/object-safety/object-safety-issue-22040.stderr b/tests/ui/object-safety/object-safety-issue-22040.stderr
index 2e59d88bdaf..c9c1437a261 100644
--- a/tests/ui/object-safety/object-safety-issue-22040.stderr
+++ b/tests/ui/object-safety/object-safety-issue-22040.stderr
@@ -13,6 +13,6 @@ LL | trait Expr: Debug + PartialEq {
    |       this trait cannot be made into an object...
    = help: only type `SExpr<'x>` implements the trait, consider using it directly instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-no-static.curr.stderr b/tests/ui/object-safety/object-safety-no-static.curr.stderr
index b40470b457b..c9e076c6577 100644
--- a/tests/ui/object-safety/object-safety-no-static.curr.stderr
+++ b/tests/ui/object-safety/object-safety-no-static.curr.stderr
@@ -21,6 +21,6 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
 LL |     fn foo() where Self: Sized {}
    |              +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-no-static.object_safe_for_dispatch.stderr b/tests/ui/object-safety/object-safety-no-static.object_safe_for_dispatch.stderr
index 1eae9a9b9da..e155a350f89 100644
--- a/tests/ui/object-safety/object-safety-no-static.object_safe_for_dispatch.stderr
+++ b/tests/ui/object-safety/object-safety-no-static.object_safe_for_dispatch.stderr
@@ -22,6 +22,6 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
 LL |     fn foo() where Self: Sized {}
    |              +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-sized-2.curr.stderr b/tests/ui/object-safety/object-safety-sized-2.curr.stderr
index b019264128e..7b91c4d665c 100644
--- a/tests/ui/object-safety/object-safety-sized-2.curr.stderr
+++ b/tests/ui/object-safety/object-safety-sized-2.curr.stderr
@@ -12,6 +12,6 @@ LL | trait Bar
 LL |     where Self : Sized
    |                  ^^^^^ ...because it requires `Self: Sized`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-sized-2.object_safe_for_dispatch.stderr b/tests/ui/object-safety/object-safety-sized-2.object_safe_for_dispatch.stderr
index 90e5c59dd02..69af9bfe92b 100644
--- a/tests/ui/object-safety/object-safety-sized-2.object_safe_for_dispatch.stderr
+++ b/tests/ui/object-safety/object-safety-sized-2.object_safe_for_dispatch.stderr
@@ -13,6 +13,6 @@ LL |     where Self : Sized
    |                  ^^^^^ ...because it requires `Self: Sized`
    = note: required for the cast from `&T` to `&dyn Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-sized.curr.stderr b/tests/ui/object-safety/object-safety-sized.curr.stderr
index 97481312142..66b5239745b 100644
--- a/tests/ui/object-safety/object-safety-sized.curr.stderr
+++ b/tests/ui/object-safety/object-safety-sized.curr.stderr
@@ -12,6 +12,6 @@ LL | trait Bar : Sized {
    |       |
    |       this trait cannot be made into an object...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-sized.object_safe_for_dispatch.stderr b/tests/ui/object-safety/object-safety-sized.object_safe_for_dispatch.stderr
index a6c22b8747e..1d0ffcffd04 100644
--- a/tests/ui/object-safety/object-safety-sized.object_safe_for_dispatch.stderr
+++ b/tests/ui/object-safety/object-safety-sized.object_safe_for_dispatch.stderr
@@ -13,6 +13,6 @@ LL | trait Bar : Sized {
    |       this trait cannot be made into an object...
    = note: required for the cast from `&T` to `&dyn Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr b/tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr
index a106ab995b0..08df069275a 100644
--- a/tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr
+++ b/tests/ui/object-safety/object-safety-supertrait-mentions-Self.stderr
@@ -12,6 +12,6 @@ LL | trait Baz : Bar<Self> {
    |       |
    |       this trait cannot be made into an object...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/occurs-check-2.stderr b/tests/ui/occurs-check-2.stderr
index b68c3fa5bcc..7b6fb9fafa2 100644
--- a/tests/ui/occurs-check-2.stderr
+++ b/tests/ui/occurs-check-2.stderr
@@ -9,6 +9,6 @@ help: consider unboxing the value
 LL |     f = *Box::new(g);
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/occurs-check-3.stderr b/tests/ui/occurs-check-3.stderr
index 04c404d543a..675133b6d50 100644
--- a/tests/ui/occurs-check-3.stderr
+++ b/tests/ui/occurs-check-3.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL | fn main() { let c; c = Clam::A(c); match c { Clam::A::<isize>(_) => { } } }
    |                        ^^^^^^^^^^ cyclic type of infinite size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/occurs-check.stderr b/tests/ui/occurs-check.stderr
index fdbbdc3abb3..1cb6b32cb23 100644
--- a/tests/ui/occurs-check.stderr
+++ b/tests/ui/occurs-check.stderr
@@ -9,6 +9,6 @@ help: consider unboxing the value
 LL |     f = *Box::new(f);
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/offset-of/offset-of-inference.stderr b/tests/ui/offset-of/offset-of-inference.stderr
index 2a520f6f906..1845822f11d 100644
--- a/tests/ui/offset-of/offset-of-inference.stderr
+++ b/tests/ui/offset-of/offset-of-inference.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     let _ = core::mem::offset_of!(Foo<_>, x);
    |                                   ^^^^^^ cannot infer type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/on-unimplemented/expected-comma-found-token.stderr b/tests/ui/on-unimplemented/expected-comma-found-token.stderr
index 048b72ee3bc..7c0874e36a6 100644
--- a/tests/ui/on-unimplemented/expected-comma-found-token.stderr
+++ b/tests/ui/on-unimplemented/expected-comma-found-token.stderr
@@ -6,5 +6,5 @@ LL |     message="the message"
 LL |     label="the label"
    |     ^^^^^ unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/on-unimplemented/feature-gate-on-unimplemented.stderr b/tests/ui/on-unimplemented/feature-gate-on-unimplemented.stderr
index a4b33963fb0..45ef22f4421 100644
--- a/tests/ui/on-unimplemented/feature-gate-on-unimplemented.stderr
+++ b/tests/ui/on-unimplemented/feature-gate-on-unimplemented.stderr
@@ -6,6 +6,6 @@ LL | #[rustc_on_unimplemented = "test error `{Self}` with `{Bar}`"]
    |
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/on-unimplemented/impl-substs.stderr b/tests/ui/on-unimplemented/impl-substs.stderr
index 36d80f3e681..e2ba2474d6c 100644
--- a/tests/ui/on-unimplemented/impl-substs.stderr
+++ b/tests/ui/on-unimplemented/impl-substs.stderr
@@ -10,6 +10,6 @@ LL |     Foo::<usize>::foo((1i32, 1i32, 1i32));
    = help: the trait `Foo<i32>` is implemented for `(i32, i32, i32)`
    = help: for that trait implementation, expected `i32`, found `usize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/on-unimplemented/issue-104140.stderr b/tests/ui/on-unimplemented/issue-104140.stderr
index ddb1f50f0bb..4ba5475d9ec 100644
--- a/tests/ui/on-unimplemented/issue-104140.stderr
+++ b/tests/ui/on-unimplemented/issue-104140.stderr
@@ -11,5 +11,5 @@ LL | #[rustc_on_unimplemented = "message"]
 LL | #[rustc_on_unimplemented(/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...")]
    | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/once-cant-call-twice-on-heap.stderr b/tests/ui/once-cant-call-twice-on-heap.stderr
index 335ac633822..33dd840dbc2 100644
--- a/tests/ui/once-cant-call-twice-on-heap.stderr
+++ b/tests/ui/once-cant-call-twice-on-heap.stderr
@@ -18,6 +18,6 @@ help: consider further restricting this bound
 LL | fn foo<F:FnOnce() + Copy>(blk: F) {
    |                   ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/operator-recovery/less-than-greater-than.stderr b/tests/ui/operator-recovery/less-than-greater-than.stderr
index 80c921535bd..21b2e77db9a 100644
--- a/tests/ui/operator-recovery/less-than-greater-than.stderr
+++ b/tests/ui/operator-recovery/less-than-greater-than.stderr
@@ -4,5 +4,5 @@ error: invalid comparison operator `<>`
 LL |     println!("{}", 1 <> 2);
    |                      ^^ help: `<>` is not a valid comparison operator, use `!=`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/operator-recovery/spaceship.stderr b/tests/ui/operator-recovery/spaceship.stderr
index ed6bd74c9b9..46a81db62b4 100644
--- a/tests/ui/operator-recovery/spaceship.stderr
+++ b/tests/ui/operator-recovery/spaceship.stderr
@@ -4,5 +4,5 @@ error: invalid comparison operator `<=>`
 LL |     println!("{}", 1 <=> 2);
    |                      ^^^ `<=>` is not a valid comparison operator, use `std::cmp::Ordering`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/or-patterns/fn-param-wrap-parens.stderr b/tests/ui/or-patterns/fn-param-wrap-parens.stderr
index 73270284131..1b9614a1378 100644
--- a/tests/ui/or-patterns/fn-param-wrap-parens.stderr
+++ b/tests/ui/or-patterns/fn-param-wrap-parens.stderr
@@ -4,5 +4,5 @@ error: top-level or-patterns are not allowed in function parameters
 LL | fn fun1(A | B: E) {}
    |         ^^^^^ help: wrap the pattern in parentheses: `(A | B)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/or-patterns/inner-or-pat.or3.stderr b/tests/ui/or-patterns/inner-or-pat.or3.stderr
index 2236a38c37b..10ec7c202e4 100644
--- a/tests/ui/or-patterns/inner-or-pat.or3.stderr
+++ b/tests/ui/or-patterns/inner-or-pat.or3.stderr
@@ -6,6 +6,6 @@ LL |     match x {
 LL |         x @ ((("h" | "ho" | "yo" | ("dude" | "w")) | () | "nop") | ("hey" | "gg")) |
    |                                                      ^^ expected `str`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/or-patterns/inner-or-pat.or4.stderr b/tests/ui/or-patterns/inner-or-pat.or4.stderr
index 058873ff5ff..97800161d82 100644
--- a/tests/ui/or-patterns/inner-or-pat.or4.stderr
+++ b/tests/ui/or-patterns/inner-or-pat.or4.stderr
@@ -6,6 +6,6 @@ LL |         (x @ "red" | (x @ "blue" |  "red")) => {
    |                       |
    |                       variable not in all patterns
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/or-patterns/while-parsing-this-or-pattern.stderr b/tests/ui/or-patterns/while-parsing-this-or-pattern.stderr
index 7ad62ff99ee..1f3d2d5d6d5 100644
--- a/tests/ui/or-patterns/while-parsing-this-or-pattern.stderr
+++ b/tests/ui/or-patterns/while-parsing-this-or-pattern.stderr
@@ -6,5 +6,5 @@ LL |         Some(42) | .=. => {}
    |         |
    |         while parsing this or-pattern starting here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/order-dependent-cast-inference.stderr b/tests/ui/order-dependent-cast-inference.stderr
index 9f4ac0fea36..ab33b703a05 100644
--- a/tests/ui/order-dependent-cast-inference.stderr
+++ b/tests/ui/order-dependent-cast-inference.stderr
@@ -6,6 +6,6 @@ LL |     let mut y = 0 as *const _;
    |
    = note: the type information given here is insufficient to check whether the pointer cast is valid
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0641`.
diff --git a/tests/ui/orphan-check-diagnostics.stderr b/tests/ui/orphan-check-diagnostics.stderr
index 7a7cea56307..b9fa7baf4c2 100644
--- a/tests/ui/orphan-check-diagnostics.stderr
+++ b/tests/ui/orphan-check-diagnostics.stderr
@@ -7,6 +7,6 @@ LL | impl<T> RemoteTrait for T where T: LocalTrait {}
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/osx-frameworks.stderr b/tests/ui/osx-frameworks.stderr
index e4a5c98dc5c..8582b8123bf 100644
--- a/tests/ui/osx-frameworks.stderr
+++ b/tests/ui/osx-frameworks.stderr
@@ -4,6 +4,6 @@ error[E0455]: link kind `framework` is only supported on Apple targets
 LL | #[link(name = "foo", kind = "framework")]
    |                             ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0455`.
diff --git a/tests/ui/packed-struct/packed-struct-generic-transmute.stderr b/tests/ui/packed-struct/packed-struct-generic-transmute.stderr
index 744c832dbb4..e91f4988429 100644
--- a/tests/ui/packed-struct/packed-struct-generic-transmute.stderr
+++ b/tests/ui/packed-struct/packed-struct-generic-transmute.stderr
@@ -7,6 +7,6 @@ LL |         let oof: Oof<[u8; 5], i32> = mem::transmute(foo);
    = note: source type: `Foo<[u8; 5], i32>` (72 bits)
    = note: target type: `Oof<[u8; 5], i32>` (96 bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/packed-struct/packed-struct-transmute.stderr b/tests/ui/packed-struct/packed-struct-transmute.stderr
index 80a8919f77b..4d75820e944 100644
--- a/tests/ui/packed-struct/packed-struct-transmute.stderr
+++ b/tests/ui/packed-struct/packed-struct-transmute.stderr
@@ -7,6 +7,6 @@ LL |         let oof: Oof = mem::transmute(foo);
    = note: source type: `Foo` (N bits)
    = note: target type: `Oof` (N bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/packed/issue-27060-2.stderr b/tests/ui/packed/issue-27060-2.stderr
index cf5f4e530dc..7ee732217e3 100644
--- a/tests/ui/packed/issue-27060-2.stderr
+++ b/tests/ui/packed/issue-27060-2.stderr
@@ -22,6 +22,6 @@ help: the `Box` type always has a statically known size and allocates its conten
 LL |     data: Box<T>,
    |           ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/packed/packed-struct-borrow-element-64bit.stderr b/tests/ui/packed/packed-struct-borrow-element-64bit.stderr
index 57630a4b470..a464b189387 100644
--- a/tests/ui/packed/packed-struct-borrow-element-64bit.stderr
+++ b/tests/ui/packed/packed-struct-borrow-element-64bit.stderr
@@ -8,6 +8,6 @@ LL |     let brw = &foo.baz;
    = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
    = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0793`.
diff --git a/tests/ui/panic-handler/panic-handler-bad-signature-1.stderr b/tests/ui/panic-handler/panic-handler-bad-signature-1.stderr
index 85555c43906..812f7a0692f 100644
--- a/tests/ui/panic-handler/panic-handler-bad-signature-1.stderr
+++ b/tests/ui/panic-handler/panic-handler-bad-signature-1.stderr
@@ -7,6 +7,6 @@ LL | fn panic(info: PanicInfo) -> () {}
    = note: expected signature `for<'a, 'b> fn(&'a PanicInfo<'b>) -> !`
               found signature `for<'a> fn(PanicInfo<'a>)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/panic-handler/panic-handler-bad-signature-2.stderr b/tests/ui/panic-handler/panic-handler-bad-signature-2.stderr
index 84eba2a5a63..736a4c7094c 100644
--- a/tests/ui/panic-handler/panic-handler-bad-signature-2.stderr
+++ b/tests/ui/panic-handler/panic-handler-bad-signature-2.stderr
@@ -7,6 +7,6 @@ LL | fn panic(info: &'static PanicInfo) -> !
    = note: expected signature `for<'a, 'b> fn(&'a PanicInfo<'b>) -> _`
               found signature `for<'a> fn(&'static PanicInfo<'a>) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/panic-handler/panic-handler-bad-signature-3.stderr b/tests/ui/panic-handler/panic-handler-bad-signature-3.stderr
index cdf55ab6534..6cd072c6396 100644
--- a/tests/ui/panic-handler/panic-handler-bad-signature-3.stderr
+++ b/tests/ui/panic-handler/panic-handler-bad-signature-3.stderr
@@ -7,6 +7,6 @@ LL | fn panic() -> ! {
    = note: expected signature `for<'a, 'b> fn(&'a PanicInfo<'b>) -> _`
               found signature `fn() -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/panic-handler/panic-handler-bad-signature-4.stderr b/tests/ui/panic-handler/panic-handler-bad-signature-4.stderr
index 5e46da12142..41a12e8dddf 100644
--- a/tests/ui/panic-handler/panic-handler-bad-signature-4.stderr
+++ b/tests/ui/panic-handler/panic-handler-bad-signature-4.stderr
@@ -4,5 +4,5 @@ error: should have no type parameters
 LL | fn panic<T>(pi: &PanicInfo) -> ! {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/panic-handler/panic-handler-bad-signature-5.stderr b/tests/ui/panic-handler/panic-handler-bad-signature-5.stderr
index 20c17587590..3dcd253d308 100644
--- a/tests/ui/panic-handler/panic-handler-bad-signature-5.stderr
+++ b/tests/ui/panic-handler/panic-handler-bad-signature-5.stderr
@@ -7,6 +7,6 @@ LL | fn panic(info: &PanicInfo<'static>) -> !
    = note: expected signature `for<'a, 'b> fn(&'a PanicInfo<'b>) -> _`
               found signature `for<'a> fn(&'a PanicInfo<'static>) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/panic-handler/panic-handler-duplicate.stderr b/tests/ui/panic-handler/panic-handler-duplicate.stderr
index 8cdc4888d02..5c50b7016b2 100644
--- a/tests/ui/panic-handler/panic-handler-duplicate.stderr
+++ b/tests/ui/panic-handler/panic-handler-duplicate.stderr
@@ -10,6 +10,6 @@ note: the lang item is first defined here
 LL | fn panic(info: &PanicInfo) -> ! {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0152`.
diff --git a/tests/ui/panic-handler/panic-handler-requires-panic-info.stderr b/tests/ui/panic-handler/panic-handler-requires-panic-info.stderr
index 2bae12efbde..06ff8e3098a 100644
--- a/tests/ui/panic-handler/panic-handler-requires-panic-info.stderr
+++ b/tests/ui/panic-handler/panic-handler-requires-panic-info.stderr
@@ -1,4 +1,4 @@
 error: language item required, but not found: `panic_info`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/panic-handler/panic-handler-std.stderr b/tests/ui/panic-handler/panic-handler-std.stderr
index 7c7feffe76a..ad9addec8eb 100644
--- a/tests/ui/panic-handler/panic-handler-std.stderr
+++ b/tests/ui/panic-handler/panic-handler-std.stderr
@@ -8,6 +8,6 @@ LL | fn panic(info: PanicInfo) -> ! {
    = note: first definition in `std` loaded from SYSROOT/libstd-*.rlib
    = note: second definition in the local crate (`panic_handler_std`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0152`.
diff --git a/tests/ui/panic-handler/panic-handler-with-target-feature.stderr b/tests/ui/panic-handler/panic-handler-with-target-feature.stderr
index 4210a4200ae..c38feab49c3 100644
--- a/tests/ui/panic-handler/panic-handler-with-target-feature.stderr
+++ b/tests/ui/panic-handler/panic-handler-with-target-feature.stderr
@@ -7,5 +7,5 @@ LL |
 LL | fn panic(info: &PanicInfo) -> ! {
    | ------------------------------- `panic_impl` language item function is not allowed to have `#[target_feature]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/panic-runtime/abort-link-to-unwind-dylib.stderr b/tests/ui/panic-runtime/abort-link-to-unwind-dylib.stderr
index 704b81ae1ce..bea1172f0e3 100644
--- a/tests/ui/panic-runtime/abort-link-to-unwind-dylib.stderr
+++ b/tests/ui/panic-runtime/abort-link-to-unwind-dylib.stderr
@@ -1,4 +1,4 @@
 error: the linked panic runtime `panic_unwind` is not compiled with this crate's panic strategy `abort`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/panic-runtime/need-abort-got-unwind.stderr b/tests/ui/panic-runtime/need-abort-got-unwind.stderr
index d29c7875fd0..2a13f45c1e2 100644
--- a/tests/ui/panic-runtime/need-abort-got-unwind.stderr
+++ b/tests/ui/panic-runtime/need-abort-got-unwind.stderr
@@ -1,4 +1,4 @@
 error: the crate `needs_abort` requires panic strategy `abort` which is incompatible with this crate's strategy of `unwind`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/panic-runtime/need-unwind-got-abort.stderr b/tests/ui/panic-runtime/need-unwind-got-abort.stderr
index 4c71df3ebc1..2a0647fe700 100644
--- a/tests/ui/panic-runtime/need-unwind-got-abort.stderr
+++ b/tests/ui/panic-runtime/need-unwind-got-abort.stderr
@@ -1,4 +1,4 @@
 error: the crate `needs_unwind` requires panic strategy `unwind` which is incompatible with this crate's strategy of `abort`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/panic-runtime/want-unwind-got-abort.stderr b/tests/ui/panic-runtime/want-unwind-got-abort.stderr
index d306ce6c5ea..ced0a7610e2 100644
--- a/tests/ui/panic-runtime/want-unwind-got-abort.stderr
+++ b/tests/ui/panic-runtime/want-unwind-got-abort.stderr
@@ -1,4 +1,4 @@
 error: the linked panic runtime `panic_runtime_abort` is not compiled with this crate's panic strategy `unwind`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/paren-span.stderr b/tests/ui/paren-span.stderr
index fc313715765..da2f57033a4 100644
--- a/tests/ui/paren-span.stderr
+++ b/tests/ui/paren-span.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `x` of struct `S` is private
 LL |     paren!(s.x);
    |              ^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/parser/assoc/assoc-oddities-1.stderr b/tests/ui/parser/assoc/assoc-oddities-1.stderr
index acf71b4893a..0d49d542f73 100644
--- a/tests/ui/parser/assoc/assoc-oddities-1.stderr
+++ b/tests/ui/parser/assoc/assoc-oddities-1.stderr
@@ -4,5 +4,5 @@ error: expected one of `.`, `;`, `?`, or `}`, found `[`
 LL |     ..if c { a } else { b }[n];
    |                            ^ expected one of `.`, `;`, `?`, or `}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/assoc/assoc-oddities-2.stderr b/tests/ui/parser/assoc/assoc-oddities-2.stderr
index d3b90c34c29..5ba8eb51bbc 100644
--- a/tests/ui/parser/assoc/assoc-oddities-2.stderr
+++ b/tests/ui/parser/assoc/assoc-oddities-2.stderr
@@ -4,5 +4,5 @@ error: expected one of `.`, `;`, `?`, or `}`, found `[`
 LL |     x..if c { a } else { b }[n];
    |                             ^ expected one of `.`, `;`, `?`, or `}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/assoc/assoc-type-in-type-arg.stderr b/tests/ui/parser/assoc/assoc-type-in-type-arg.stderr
index b637702f21e..259a836d097 100644
--- a/tests/ui/parser/assoc/assoc-type-in-type-arg.stderr
+++ b/tests/ui/parser/assoc/assoc-type-in-type-arg.stderr
@@ -4,5 +4,5 @@ error: bounds on associated types do not belong here
 LL | struct Bar<'a, Item: Tr, <Item as Tr>::TrSubtype: 'a> {
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ belongs in `where` clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-bad-meta-2.stderr b/tests/ui/parser/attribute/attr-bad-meta-2.stderr
index 6fc6fb665a8..98321827dfa 100644
--- a/tests/ui/parser/attribute/attr-bad-meta-2.stderr
+++ b/tests/ui/parser/attribute/attr-bad-meta-2.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `]`
 LL | #[path =]
    |         ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-bad-meta-3.stderr b/tests/ui/parser/attribute/attr-bad-meta-3.stderr
index 4fa420c79fc..13eed2e1dc8 100644
--- a/tests/ui/parser/attribute/attr-bad-meta-3.stderr
+++ b/tests/ui/parser/attribute/attr-bad-meta-3.stderr
@@ -4,5 +4,5 @@ error: expected `]`, found `token`
 LL | #[path() token]
    |          ^^^^^ expected `]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-bad-meta.stderr b/tests/ui/parser/attribute/attr-bad-meta.stderr
index 8d65c423c8d..4ca7d6d9fe6 100644
--- a/tests/ui/parser/attribute/attr-bad-meta.stderr
+++ b/tests/ui/parser/attribute/attr-bad-meta.stderr
@@ -4,5 +4,5 @@ error: expected one of `(`, `::`, `=`, `[`, `]`, or `{`, found `*`
 LL | #[path*]
    |       ^ expected one of `(`, `::`, `=`, `[`, `]`, or `{`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-before-eof.stderr b/tests/ui/parser/attribute/attr-before-eof.stderr
index a2acb94372b..18a9d77bf71 100644
--- a/tests/ui/parser/attribute/attr-before-eof.stderr
+++ b/tests/ui/parser/attribute/attr-before-eof.stderr
@@ -4,5 +4,5 @@ error: expected item after attributes
 LL | #[derive(Debug)]
    | ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-dangling-in-fn.stderr b/tests/ui/parser/attribute/attr-dangling-in-fn.stderr
index b1bb3ab3b17..c7b948ea8f7 100644
--- a/tests/ui/parser/attribute/attr-dangling-in-fn.stderr
+++ b/tests/ui/parser/attribute/attr-dangling-in-fn.stderr
@@ -4,5 +4,5 @@ error: expected statement after outer attribute
 LL |   #[foo = "bar"]
    |   ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-dangling-in-mod.stderr b/tests/ui/parser/attribute/attr-dangling-in-mod.stderr
index 1c892eac08f..882400c1d6f 100644
--- a/tests/ui/parser/attribute/attr-dangling-in-mod.stderr
+++ b/tests/ui/parser/attribute/attr-dangling-in-mod.stderr
@@ -4,5 +4,5 @@ error: expected item after attributes
 LL | #[foo = "bar"]
    | ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-with-a-semicolon.stderr b/tests/ui/parser/attribute/attr-with-a-semicolon.stderr
index 0de3490b8ea..b77f30fdb59 100644
--- a/tests/ui/parser/attribute/attr-with-a-semicolon.stderr
+++ b/tests/ui/parser/attribute/attr-with-a-semicolon.stderr
@@ -10,5 +10,5 @@ LL - #[derive(Debug, Clone)];
 LL + #[derive(Debug, Clone)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr.stderr b/tests/ui/parser/attribute/attr.stderr
index 7cd0ac2244a..2e0b16efb6c 100644
--- a/tests/ui/parser/attribute/attr.stderr
+++ b/tests/ui/parser/attribute/attr.stderr
@@ -13,5 +13,5 @@ LL - #![lang = "foo"]
 LL + #[lang = "foo"]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attribute-with-no-generics-in-parameter-list.stderr b/tests/ui/parser/attribute/attribute-with-no-generics-in-parameter-list.stderr
index 4c5964715db..3279e4e5943 100644
--- a/tests/ui/parser/attribute/attribute-with-no-generics-in-parameter-list.stderr
+++ b/tests/ui/parser/attribute/attribute-with-no-generics-in-parameter-list.stderr
@@ -4,5 +4,5 @@ error: attribute without generic parameters
 LL | fn foo<#[attr]>() {}
    |        ^^^^^^^ attributes are only permitted when preceding parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attrs-after-extern-mod.stderr b/tests/ui/parser/attribute/attrs-after-extern-mod.stderr
index 135d98457e1..f2bafa54f8d 100644
--- a/tests/ui/parser/attribute/attrs-after-extern-mod.stderr
+++ b/tests/ui/parser/attribute/attrs-after-extern-mod.stderr
@@ -8,5 +8,5 @@ LL |     #[cfg(stage37)]
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-escape-suggest-raw-string.stderr b/tests/ui/parser/bad-escape-suggest-raw-string.stderr
index 45d24bc0fb3..6dd4ad512a8 100644
--- a/tests/ui/parser/bad-escape-suggest-raw-string.stderr
+++ b/tests/ui/parser/bad-escape-suggest-raw-string.stderr
@@ -10,5 +10,5 @@ help: if you meant to write a literal backslash (perhaps escaping in a regular e
 LL |     let bad = r"ab\[c";
    |               ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-let-as-field.stderr b/tests/ui/parser/bad-let-as-field.stderr
index 57def42b1ee..8568036d056 100644
--- a/tests/ui/parser/bad-let-as-field.stderr
+++ b/tests/ui/parser/bad-let-as-field.stderr
@@ -11,5 +11,5 @@ help: escape `let` to use it as an identifier
 LL |     r#let: i32,
    |     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-match.stderr b/tests/ui/parser/bad-match.stderr
index 13784c409cd..8e7878c2b6c 100644
--- a/tests/ui/parser/bad-match.stderr
+++ b/tests/ui/parser/bad-match.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `x`
 LL |   let isize x = 5;
    |             ^ expected one of `:`, `;`, `=`, `@`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-name.stderr b/tests/ui/parser/bad-name.stderr
index a36b67794fa..e133d4e4839 100644
--- a/tests/ui/parser/bad-name.stderr
+++ b/tests/ui/parser/bad-name.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `.`
 LL |   let x.y::<isize>.z foo;
    |        ^ expected one of `:`, `;`, `=`, `@`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-pointer-type.stderr b/tests/ui/parser/bad-pointer-type.stderr
index e843c49886b..f409d4d9901 100644
--- a/tests/ui/parser/bad-pointer-type.stderr
+++ b/tests/ui/parser/bad-pointer-type.stderr
@@ -11,5 +11,5 @@ LL | fn foo(_: *mut ()) {
 LL | fn foo(_: *const ()) {
    |            +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-struct-following-where.stderr b/tests/ui/parser/bad-struct-following-where.stderr
index bb79776dc84..f27efc95f91 100644
--- a/tests/ui/parser/bad-struct-following-where.stderr
+++ b/tests/ui/parser/bad-struct-following-where.stderr
@@ -4,5 +4,5 @@ error: expected `{` after struct name, found `!`
 LL | struct A where T: Sized !
    |                         ^ expected `{` after struct name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-value-ident-false.stderr b/tests/ui/parser/bad-value-ident-false.stderr
index 30c05ecf30a..97121949674 100644
--- a/tests/ui/parser/bad-value-ident-false.stderr
+++ b/tests/ui/parser/bad-value-ident-false.stderr
@@ -9,5 +9,5 @@ help: escape `false` to use it as an identifier
 LL | fn r#false() { }
    |    ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bad-value-ident-true.stderr b/tests/ui/parser/bad-value-ident-true.stderr
index 74137fa7001..b7b73e5f814 100644
--- a/tests/ui/parser/bad-value-ident-true.stderr
+++ b/tests/ui/parser/bad-value-ident-true.stderr
@@ -9,5 +9,5 @@ help: escape `true` to use it as an identifier
 LL | fn r#true() { }
    |    ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/better-expected.stderr b/tests/ui/parser/better-expected.stderr
index 21bf8d19a72..6cb9a49605f 100644
--- a/tests/ui/parser/better-expected.stderr
+++ b/tests/ui/parser/better-expected.stderr
@@ -6,5 +6,5 @@ LL |     let x: [isize 3];
    |         |
    |         while parsing the type for `x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bind-struct-early-modifiers.stderr b/tests/ui/parser/bind-struct-early-modifiers.stderr
index b35762a887c..6b366a99569 100644
--- a/tests/ui/parser/bind-struct-early-modifiers.stderr
+++ b/tests/ui/parser/bind-struct-early-modifiers.stderr
@@ -6,5 +6,5 @@ LL |         Foo { ref x: ref x } => {},
    |         |
    |         while parsing the fields for this pattern
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bound-single-question-mark.stderr b/tests/ui/parser/bound-single-question-mark.stderr
index 82937a517b5..f339c202275 100644
--- a/tests/ui/parser/bound-single-question-mark.stderr
+++ b/tests/ui/parser/bound-single-question-mark.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `>`
 LL | fn f<T: ?>() {}
    |          ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bounds-lifetime-1.stderr b/tests/ui/parser/bounds-lifetime-1.stderr
index 000e84f635b..101704f6442 100644
--- a/tests/ui/parser/bounds-lifetime-1.stderr
+++ b/tests/ui/parser/bounds-lifetime-1.stderr
@@ -4,5 +4,5 @@ error: expected one of `,`, `:`, or `>`, found `'b`
 LL | type A = for<'a 'b> fn();
    |                 ^^ expected one of `,`, `:`, or `>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bounds-lifetime-2.stderr b/tests/ui/parser/bounds-lifetime-2.stderr
index dd3e69c1139..f39cc604eec 100644
--- a/tests/ui/parser/bounds-lifetime-2.stderr
+++ b/tests/ui/parser/bounds-lifetime-2.stderr
@@ -4,5 +4,5 @@ error: expected one of `,`, `:`, or `>`, found `+`
 LL | type A = for<'a + 'b> fn();
    |                 ^ expected one of `,`, `:`, or `>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bounds-lifetime-where-1.stderr b/tests/ui/parser/bounds-lifetime-where-1.stderr
index b6bd866938b..f79b4fa0338 100644
--- a/tests/ui/parser/bounds-lifetime-where-1.stderr
+++ b/tests/ui/parser/bounds-lifetime-where-1.stderr
@@ -4,5 +4,5 @@ error: expected `:`, found `;`
 LL | type A where 'a;
    |                ^ expected `:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bounds-lifetime-where.stderr b/tests/ui/parser/bounds-lifetime-where.stderr
index 785a1fb6793..9dd963afc79 100644
--- a/tests/ui/parser/bounds-lifetime-where.stderr
+++ b/tests/ui/parser/bounds-lifetime-where.stderr
@@ -4,5 +4,5 @@ error: expected one of `;`, `=`, `where`, lifetime, or type, found `,`
 LL | type A where , = u8;
    |              ^ expected one of `;`, `=`, `where`, lifetime, or type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bounds-lifetime.stderr b/tests/ui/parser/bounds-lifetime.stderr
index e47a21d892b..26a3e78633a 100644
--- a/tests/ui/parser/bounds-lifetime.stderr
+++ b/tests/ui/parser/bounds-lifetime.stderr
@@ -4,5 +4,5 @@ error: expected one of `#`, `>`, `const`, identifier, or lifetime, found `,`
 LL | type A = for<,> fn();
    |              ^ expected one of `#`, `>`, `const`, identifier, or lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/bounds-type-where.stderr b/tests/ui/parser/bounds-type-where.stderr
index 5636ee75c97..709d3143098 100644
--- a/tests/ui/parser/bounds-type-where.stderr
+++ b/tests/ui/parser/bounds-type-where.stderr
@@ -4,5 +4,5 @@ error: expected one of `!`, `(`, `+`, `::`, `:`, `<`, `==`, or `=`, found `,`
 LL | type A where T, = u8;
    |               ^ expected one of 8 possible tokens
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/can-begin-expr-check.stderr b/tests/ui/parser/can-begin-expr-check.stderr
index 9569ababad8..247009be0cb 100644
--- a/tests/ui/parser/can-begin-expr-check.stderr
+++ b/tests/ui/parser/can-begin-expr-check.stderr
@@ -4,5 +4,5 @@ error: expected one of `;`, `}`, or an operator, found keyword `enum`
 LL |     return enum;
    |            ^^^^ expected one of `;`, `}`, or an operator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/char/whitespace-character-literal.stderr b/tests/ui/parser/char/whitespace-character-literal.stderr
index d73de41a809..3bd048f8f62 100644
--- a/tests/ui/parser/char/whitespace-character-literal.stderr
+++ b/tests/ui/parser/char/whitespace-character-literal.stderr
@@ -12,5 +12,5 @@ note: there are non-printing characters, the full sequence is `\u{200a}x\u{200b}
 LL |     let _hair_space_around = ' x​';
    |                               ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/class-implements-bad-trait.stderr b/tests/ui/parser/class-implements-bad-trait.stderr
index 3a4dea95d5d..5290e3594d5 100644
--- a/tests/ui/parser/class-implements-bad-trait.stderr
+++ b/tests/ui/parser/class-implements-bad-trait.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `::`, found `cat`
 LL | class cat : nonexistent {
    |       ^^^ expected one of `!` or `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/closure-return-syntax.stderr b/tests/ui/parser/closure-return-syntax.stderr
index 3d16a2067cc..eb8428854af 100644
--- a/tests/ui/parser/closure-return-syntax.stderr
+++ b/tests/ui/parser/closure-return-syntax.stderr
@@ -9,5 +9,5 @@ help: try placing this code inside a block
 LL |     let x = || -> i32 { 22 };
    |                       +    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/column-offset-1-based.stderr b/tests/ui/parser/column-offset-1-based.stderr
index 766d72a0a5a..d837466d9af 100644
--- a/tests/ui/parser/column-offset-1-based.stderr
+++ b/tests/ui/parser/column-offset-1-based.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `[`, found `<eof>`
 LL | #
    | ^ expected one of `!` or `[`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/deep-unmatched-angle-brackets.stderr b/tests/ui/parser/deep-unmatched-angle-brackets.stderr
index 1f285037482..7c9033f2f32 100644
--- a/tests/ui/parser/deep-unmatched-angle-brackets.stderr
+++ b/tests/ui/parser/deep-unmatched-angle-brackets.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL |         <f::<f::<f::<f::<f::<f::<f::<f::<f::<f::<f::<f::<f::<>>();
    |                                                               +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/deli-ident-issue-1.stderr b/tests/ui/parser/deli-ident-issue-1.stderr
index eb5073e14cf..78f5d7b63b9 100644
--- a/tests/ui/parser/deli-ident-issue-1.stderr
+++ b/tests/ui/parser/deli-ident-issue-1.stderr
@@ -13,5 +13,5 @@ LL |     }
 LL | fn main() { }
    |                                                                  ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/enum-2.stderr b/tests/ui/parser/diff-markers/enum-2.stderr
index 63da5c2a6e1..20e551c2f95 100644
--- a/tests/ui/parser/diff-markers/enum-2.stderr
+++ b/tests/ui/parser/diff-markers/enum-2.stderr
@@ -17,5 +17,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/enum.stderr b/tests/ui/parser/diff-markers/enum.stderr
index abbf3fb41e7..be94331dce5 100644
--- a/tests/ui/parser/diff-markers/enum.stderr
+++ b/tests/ui/parser/diff-markers/enum.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/fn-arg.stderr b/tests/ui/parser/diff-markers/fn-arg.stderr
index 933a206410e..aabcb826c12 100644
--- a/tests/ui/parser/diff-markers/fn-arg.stderr
+++ b/tests/ui/parser/diff-markers/fn-arg.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/item-with-attr.stderr b/tests/ui/parser/diff-markers/item-with-attr.stderr
index 850e2368e55..eefb2792e90 100644
--- a/tests/ui/parser/diff-markers/item-with-attr.stderr
+++ b/tests/ui/parser/diff-markers/item-with-attr.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/item.stderr b/tests/ui/parser/diff-markers/item.stderr
index 9ab3631a60e..a3092ebfcfd 100644
--- a/tests/ui/parser/diff-markers/item.stderr
+++ b/tests/ui/parser/diff-markers/item.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/statement.stderr b/tests/ui/parser/diff-markers/statement.stderr
index 7ca2495b829..c6c6cae8765 100644
--- a/tests/ui/parser/diff-markers/statement.stderr
+++ b/tests/ui/parser/diff-markers/statement.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/struct-expr.stderr b/tests/ui/parser/diff-markers/struct-expr.stderr
index d70476a9833..bdea8c841c6 100644
--- a/tests/ui/parser/diff-markers/struct-expr.stderr
+++ b/tests/ui/parser/diff-markers/struct-expr.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/struct.stderr b/tests/ui/parser/diff-markers/struct.stderr
index cc0b3da664e..749941290cb 100644
--- a/tests/ui/parser/diff-markers/struct.stderr
+++ b/tests/ui/parser/diff-markers/struct.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/trait-item.stderr b/tests/ui/parser/diff-markers/trait-item.stderr
index cdc19f8e076..f01bbe8ba03 100644
--- a/tests/ui/parser/diff-markers/trait-item.stderr
+++ b/tests/ui/parser/diff-markers/trait-item.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/tuple-struct.stderr b/tests/ui/parser/diff-markers/tuple-struct.stderr
index d673db89837..8dae123c96d 100644
--- a/tests/ui/parser/diff-markers/tuple-struct.stderr
+++ b/tests/ui/parser/diff-markers/tuple-struct.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/unclosed-delims-in-macro.stderr b/tests/ui/parser/diff-markers/unclosed-delims-in-macro.stderr
index e0b6f1b5eb8..6995b8e6f23 100644
--- a/tests/ui/parser/diff-markers/unclosed-delims-in-macro.stderr
+++ b/tests/ui/parser/diff-markers/unclosed-delims-in-macro.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> 7a4f13c blah blah blah
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/unclosed-delims.stderr b/tests/ui/parser/diff-markers/unclosed-delims.stderr
index 67199179b39..d4636150e66 100644
--- a/tests/ui/parser/diff-markers/unclosed-delims.stderr
+++ b/tests/ui/parser/diff-markers/unclosed-delims.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> 7a4f13c blah blah blah
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/diff-markers/use-statement.stderr b/tests/ui/parser/diff-markers/use-statement.stderr
index 12e6f57dd50..6d376166a7f 100644
--- a/tests/ui/parser/diff-markers/use-statement.stderr
+++ b/tests/ui/parser/diff-markers/use-statement.stderr
@@ -14,5 +14,5 @@ LL | >>>>>>> branch
    = help: if you're in the middle of a rebase, the top section is the code being rebased onto and the bottom section is the code coming from the current commit being rebased
    = note: for an explanation on these markers from the `git` documentation, visit <https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_checking_out_conflicts>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/do-not-suggest-semicolon-before-array.stderr b/tests/ui/parser/do-not-suggest-semicolon-before-array.stderr
index 7b43c77005e..0227439ce06 100644
--- a/tests/ui/parser/do-not-suggest-semicolon-before-array.stderr
+++ b/tests/ui/parser/do-not-suggest-semicolon-before-array.stderr
@@ -6,5 +6,5 @@ LL |     [1, 3)
    |     |
    |     unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/do-not-suggest-semicolon-between-macro-without-exclamation-mark-and-array.stderr b/tests/ui/parser/do-not-suggest-semicolon-between-macro-without-exclamation-mark-and-array.stderr
index 2fe6a28eeb4..2796312f4ad 100644
--- a/tests/ui/parser/do-not-suggest-semicolon-between-macro-without-exclamation-mark-and-array.stderr
+++ b/tests/ui/parser/do-not-suggest-semicolon-between-macro-without-exclamation-mark-and-array.stderr
@@ -4,5 +4,5 @@ error: expected one of `.`, `?`, `]`, or an operator, found `,`
 LL |     let _x = vec[1, 2, 3];
    |                   ^ expected one of `.`, `?`, `]`, or an operator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/doc-before-attr.stderr b/tests/ui/parser/doc-before-attr.stderr
index 14fd01af2f9..0298b9b60d2 100644
--- a/tests/ui/parser/doc-before-attr.stderr
+++ b/tests/ui/parser/doc-before-attr.stderr
@@ -6,5 +6,5 @@ LL | /// hi
 LL | #[derive(Debug)]
    | ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/doc-before-eof.stderr b/tests/ui/parser/doc-before-eof.stderr
index 82756626765..e41d02f0ea4 100644
--- a/tests/ui/parser/doc-before-eof.stderr
+++ b/tests/ui/parser/doc-before-eof.stderr
@@ -4,5 +4,5 @@ error: expected item after doc comment
 LL | /// hi
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this doc comment doesn't document anything
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/doc-before-extern-rbrace.stderr b/tests/ui/parser/doc-before-extern-rbrace.stderr
index 8fa12ec261e..4d952e29426 100644
--- a/tests/ui/parser/doc-before-extern-rbrace.stderr
+++ b/tests/ui/parser/doc-before-extern-rbrace.stderr
@@ -6,6 +6,6 @@ LL |     /// hi
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0584`.
diff --git a/tests/ui/parser/doc-before-fn-rbrace.stderr b/tests/ui/parser/doc-before-fn-rbrace.stderr
index 6ea68e42b4c..bbe6b714417 100644
--- a/tests/ui/parser/doc-before-fn-rbrace.stderr
+++ b/tests/ui/parser/doc-before-fn-rbrace.stderr
@@ -6,6 +6,6 @@ LL |     /// document
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/doc-before-identifier.stderr b/tests/ui/parser/doc-before-identifier.stderr
index 940d293b678..501b05c5a94 100644
--- a/tests/ui/parser/doc-before-identifier.stderr
+++ b/tests/ui/parser/doc-before-identifier.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found doc comment `/// document`
 LL | fn /// document
    |    ^^^^^^^^^^^^ expected identifier, found doc comment
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/doc-before-mod-rbrace.stderr b/tests/ui/parser/doc-before-mod-rbrace.stderr
index d5749c66cd2..00aa40b6211 100644
--- a/tests/ui/parser/doc-before-mod-rbrace.stderr
+++ b/tests/ui/parser/doc-before-mod-rbrace.stderr
@@ -4,5 +4,5 @@ error: expected item after doc comment
 LL |     /// document
    |     ^^^^^^^^^^^^ this doc comment doesn't document anything
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/doc-before-rbrace.stderr b/tests/ui/parser/doc-before-rbrace.stderr
index 4d4741dfe59..3c4ea5375b5 100644
--- a/tests/ui/parser/doc-before-rbrace.stderr
+++ b/tests/ui/parser/doc-before-rbrace.stderr
@@ -6,6 +6,6 @@ LL |     println!("Hi"); /// hi
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/doc-before-semi.stderr b/tests/ui/parser/doc-before-semi.stderr
index a879e13ffbd..f3454d30d19 100644
--- a/tests/ui/parser/doc-before-semi.stderr
+++ b/tests/ui/parser/doc-before-semi.stderr
@@ -6,6 +6,6 @@ LL |     /// hi
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/doc-before-struct-rbrace-1.stderr b/tests/ui/parser/doc-before-struct-rbrace-1.stderr
index 94934f734b3..62a27740f56 100644
--- a/tests/ui/parser/doc-before-struct-rbrace-1.stderr
+++ b/tests/ui/parser/doc-before-struct-rbrace-1.stderr
@@ -9,6 +9,6 @@ LL |     /// document
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/doc-before-struct-rbrace-2.stderr b/tests/ui/parser/doc-before-struct-rbrace-2.stderr
index 6b5c8c1f8b5..66c6ce8940a 100644
--- a/tests/ui/parser/doc-before-struct-rbrace-2.stderr
+++ b/tests/ui/parser/doc-before-struct-rbrace-2.stderr
@@ -6,6 +6,6 @@ LL |     a: u8 /// document
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/doc-inside-trait-item.stderr b/tests/ui/parser/doc-inside-trait-item.stderr
index 900124adcc3..df1ebc1106f 100644
--- a/tests/ui/parser/doc-inside-trait-item.stderr
+++ b/tests/ui/parser/doc-inside-trait-item.stderr
@@ -6,6 +6,6 @@ LL |     /// empty doc
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0584`.
diff --git a/tests/ui/parser/dotdotdot-expr.stderr b/tests/ui/parser/dotdotdot-expr.stderr
index e7203f24d3f..208c04bd3df 100644
--- a/tests/ui/parser/dotdotdot-expr.stderr
+++ b/tests/ui/parser/dotdotdot-expr.stderr
@@ -13,5 +13,5 @@ help: or `..=` for an inclusive range
 LL |     let _redemptive = 1..=21;
    |                        ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/double-pointer.stderr b/tests/ui/parser/double-pointer.stderr
index 10aedbb92a1..25403c5b027 100644
--- a/tests/ui/parser/double-pointer.stderr
+++ b/tests/ui/parser/double-pointer.stderr
@@ -11,5 +11,5 @@ LL |     let dptr: *mut *const i32 = &ptr;
 LL |     let dptr: *const *const i32 = &ptr;
    |                +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/duplicate-visibility.stderr b/tests/ui/parser/duplicate-visibility.stderr
index 8ecebf01f17..b578b1fe26e 100644
--- a/tests/ui/parser/duplicate-visibility.stderr
+++ b/tests/ui/parser/duplicate-visibility.stderr
@@ -18,5 +18,5 @@ note: explicit visibility first seen here
 LL |     pub pub fn foo();
    |     ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/empty-impl-semicolon.stderr b/tests/ui/parser/empty-impl-semicolon.stderr
index 6ed309eba93..cb15c36e649 100644
--- a/tests/ui/parser/empty-impl-semicolon.stderr
+++ b/tests/ui/parser/empty-impl-semicolon.stderr
@@ -6,5 +6,5 @@ LL | impl Foo;
    |
    = help: try using `{}` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/extern-crate-unexpected-token.stderr b/tests/ui/parser/extern-crate-unexpected-token.stderr
index e9d287ac0e9..f83bb3e3e35 100644
--- a/tests/ui/parser/extern-crate-unexpected-token.stderr
+++ b/tests/ui/parser/extern-crate-unexpected-token.stderr
@@ -4,5 +4,5 @@ error: expected one of `crate` or `{`, found `crte`
 LL | extern crte foo;
    |        ^^^^ expected one of `crate` or `{`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/extern-expected-fn-or-brace.stderr b/tests/ui/parser/extern-expected-fn-or-brace.stderr
index 258a2c2680a..c2200e03763 100644
--- a/tests/ui/parser/extern-expected-fn-or-brace.stderr
+++ b/tests/ui/parser/extern-expected-fn-or-brace.stderr
@@ -4,5 +4,5 @@ error: expected `{`, found keyword `mod`
 LL | extern "C" mod foo;
    |            ^^^ expected `{`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/extern-foreign-crate.stderr b/tests/ui/parser/extern-foreign-crate.stderr
index eb75c0fc9c6..10c58aeb571 100644
--- a/tests/ui/parser/extern-foreign-crate.stderr
+++ b/tests/ui/parser/extern-foreign-crate.stderr
@@ -4,5 +4,5 @@ error: expected one of `;` or `as`, found `{`
 LL | extern crate foo {}
    |                  ^ expected one of `;` or `as`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/extern-no-fn.stderr b/tests/ui/parser/extern-no-fn.stderr
index d9183d56463..2e434afb218 100644
--- a/tests/ui/parser/extern-no-fn.stderr
+++ b/tests/ui/parser/extern-no-fn.stderr
@@ -8,5 +8,5 @@ LL |     f();
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/fn-colon-return-type.stderr b/tests/ui/parser/fn-colon-return-type.stderr
index 1de91878205..b61a62a17f7 100644
--- a/tests/ui/parser/fn-colon-return-type.stderr
+++ b/tests/ui/parser/fn-colon-return-type.stderr
@@ -4,5 +4,5 @@ error: return types are denoted using `->`
 LL | fn foo(x: i32): i32 {
    |               ^ help: use `->` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/fn-defined-using-def.stderr b/tests/ui/parser/fn-defined-using-def.stderr
index f34329012a0..972c861c750 100644
--- a/tests/ui/parser/fn-defined-using-def.stderr
+++ b/tests/ui/parser/fn-defined-using-def.stderr
@@ -6,5 +6,5 @@ LL | def foo() {}
    | |
    | help: write `fn` instead of `def` to declare a function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/fn-defined-using-fun.stderr b/tests/ui/parser/fn-defined-using-fun.stderr
index 2f6cfff350c..3c8e586c0e8 100644
--- a/tests/ui/parser/fn-defined-using-fun.stderr
+++ b/tests/ui/parser/fn-defined-using-fun.stderr
@@ -6,5 +6,5 @@ LL | fun foo() {}
    | |
    | help: write `fn` instead of `fun` to declare a function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/fn-defined-using-func.stderr b/tests/ui/parser/fn-defined-using-func.stderr
index 355741e8949..9dd90798d92 100644
--- a/tests/ui/parser/fn-defined-using-func.stderr
+++ b/tests/ui/parser/fn-defined-using-func.stderr
@@ -6,5 +6,5 @@ LL | func foo() {}
    | |
    | help: write `fn` instead of `func` to declare a function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/fn-defined-using-function.stderr b/tests/ui/parser/fn-defined-using-function.stderr
index 43c33a2cdd7..504ab1bb93d 100644
--- a/tests/ui/parser/fn-defined-using-function.stderr
+++ b/tests/ui/parser/fn-defined-using-function.stderr
@@ -6,5 +6,5 @@ LL | function foo() {}
    | |
    | help: write `fn` instead of `function` to declare a function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/generic-statics.stderr b/tests/ui/parser/generic-statics.stderr
index c757232b061..eb2e273602e 100644
--- a/tests/ui/parser/generic-statics.stderr
+++ b/tests/ui/parser/generic-statics.stderr
@@ -4,5 +4,5 @@ error: static items may not have generic parameters
 LL | static S<T>: i32 = 0;
    |         ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/if-in-in.stderr b/tests/ui/parser/if-in-in.stderr
index 0e69bc4b2ce..6117370c0ce 100644
--- a/tests/ui/parser/if-in-in.stderr
+++ b/tests/ui/parser/if-in-in.stderr
@@ -6,5 +6,5 @@ LL |     for i in in 1..2 {
    |           |
    |           help: remove the duplicated `in`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/impl-item-const-semantic-fail.stderr b/tests/ui/parser/impl-item-const-semantic-fail.stderr
index ec3bee0ce68..579f4c29c52 100644
--- a/tests/ui/parser/impl-item-const-semantic-fail.stderr
+++ b/tests/ui/parser/impl-item-const-semantic-fail.stderr
@@ -6,5 +6,5 @@ LL |     const Y: u8;
    |                |
    |                help: provide a definition for the constant: `= <expr>;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/impl-item-fn-no-body-semantic-fail.stderr b/tests/ui/parser/impl-item-fn-no-body-semantic-fail.stderr
index 1acb727368b..1704d99cf29 100644
--- a/tests/ui/parser/impl-item-fn-no-body-semantic-fail.stderr
+++ b/tests/ui/parser/impl-item-fn-no-body-semantic-fail.stderr
@@ -6,5 +6,5 @@ LL |     fn f();
    |           |
    |           help: provide a definition for the function: `{ <body> }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/impl-on-unsized-typo.stderr b/tests/ui/parser/impl-on-unsized-typo.stderr
index 23dcc1efd68..62e0d085e27 100644
--- a/tests/ui/parser/impl-on-unsized-typo.stderr
+++ b/tests/ui/parser/impl-on-unsized-typo.stderr
@@ -4,5 +4,5 @@ error: expected one of `,`, `:`, `=`, or `>`, found `?`
 LL | impl<T ?Sized> Tr for T {}
    |        ^ expected one of `,`, `:`, `=`, or `>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/import-from-path.stderr b/tests/ui/parser/import-from-path.stderr
index 93bdf82d0f5..b63e48d6679 100644
--- a/tests/ui/parser/import-from-path.stderr
+++ b/tests/ui/parser/import-from-path.stderr
@@ -6,5 +6,5 @@ LL | use foo::{bar}::baz
    |
    = note: glob-like brace syntax must be last on the path
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/import-from-rename.stderr b/tests/ui/parser/import-from-rename.stderr
index d78f6de9222..2f267a8d026 100644
--- a/tests/ui/parser/import-from-rename.stderr
+++ b/tests/ui/parser/import-from-rename.stderr
@@ -6,5 +6,5 @@ LL | use foo::{bar} as baz;
    |
    = note: glob-like brace syntax must be last on the path
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/import-glob-path.stderr b/tests/ui/parser/import-glob-path.stderr
index a93ef255c94..3bde32d1ea4 100644
--- a/tests/ui/parser/import-glob-path.stderr
+++ b/tests/ui/parser/import-glob-path.stderr
@@ -6,5 +6,5 @@ LL | use foo::*::bar
    |
    = note: the wildcard token must be last on the path
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/import-glob-rename.stderr b/tests/ui/parser/import-glob-rename.stderr
index e1a026b639e..24e6c3f0006 100644
--- a/tests/ui/parser/import-glob-rename.stderr
+++ b/tests/ui/parser/import-glob-rename.stderr
@@ -6,5 +6,5 @@ LL | use foo::* as baz;
    |
    = note: the wildcard token must be last on the path
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/inner-attr-after-doc-comment.stderr b/tests/ui/parser/inner-attr-after-doc-comment.stderr
index 3ec3ad8e977..6dbc0fd93fd 100644
--- a/tests/ui/parser/inner-attr-after-doc-comment.stderr
+++ b/tests/ui/parser/inner-attr-after-doc-comment.stderr
@@ -19,5 +19,5 @@ LL - #![recursion_limit="100"]
 LL + #[recursion_limit="100"]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/inner-attr.stderr b/tests/ui/parser/inner-attr.stderr
index 331c254a52b..57ca164fc15 100644
--- a/tests/ui/parser/inner-attr.stderr
+++ b/tests/ui/parser/inner-attr.stderr
@@ -16,5 +16,5 @@ LL - #![recursion_limit="100"]
 LL + #[recursion_limit="100"]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/int-literal-too-large-span.stderr b/tests/ui/parser/int-literal-too-large-span.stderr
index 49d6aa5eff8..d65a3052ba9 100644
--- a/tests/ui/parser/int-literal-too-large-span.stderr
+++ b/tests/ui/parser/int-literal-too-large-span.stderr
@@ -6,5 +6,5 @@ LL |     99999999999999999999999999999999999999999999999999999999999999999999999
    |
    = note: value exceeds limit of `340282366920938463463374607431768211455`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/integer-literal-start-ident.stderr b/tests/ui/parser/integer-literal-start-ident.stderr
index b2c66129656..27f0baec80c 100644
--- a/tests/ui/parser/integer-literal-start-ident.stderr
+++ b/tests/ui/parser/integer-literal-start-ident.stderr
@@ -10,5 +10,5 @@ help: identifiers cannot start with a number
 LL | fn 1main() {}
    |    ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/intersection-patterns-2.stderr b/tests/ui/parser/intersection-patterns-2.stderr
index f7e78814ca5..df34e2a42a9 100644
--- a/tests/ui/parser/intersection-patterns-2.stderr
+++ b/tests/ui/parser/intersection-patterns-2.stderr
@@ -9,5 +9,5 @@ LL |         Some(x) @ Some(y) => {}
    |
    = note: bindings are `x`, `mut x`, `ref x`, and `ref mut x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-100197-mut-let.stderr b/tests/ui/parser/issues/issue-100197-mut-let.stderr
index 86658e4f39f..07d13688140 100644
--- a/tests/ui/parser/issues/issue-100197-mut-let.stderr
+++ b/tests/ui/parser/issues/issue-100197-mut-let.stderr
@@ -4,5 +4,5 @@ error: invalid variable declaration
 LL |     mut let _x = 123;
    |     ^^^^^^^ help: switch the order of `mut` and `let`: `let mut`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-101477-let.stderr b/tests/ui/parser/issues/issue-101477-let.stderr
index 1b30d4b1786..56348357397 100644
--- a/tests/ui/parser/issues/issue-101477-let.stderr
+++ b/tests/ui/parser/issues/issue-101477-let.stderr
@@ -4,5 +4,5 @@ error: unexpected `==`
 LL |     let x == 2;
    |           ^^ help: try using `=` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-101540.stderr b/tests/ui/parser/issues/issue-101540.stderr
index 8af88705002..40f1d339a45 100644
--- a/tests/ui/parser/issues/issue-101540.stderr
+++ b/tests/ui/parser/issues/issue-101540.stderr
@@ -8,5 +8,5 @@ LL |     struct S2 {
    |
    = help: consider creating a new `struct` definition instead of nesting
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-102182-impl-trait-recover.stderr b/tests/ui/parser/issues/issue-102182-impl-trait-recover.stderr
index 52b6ae5df35..cf05337f26c 100644
--- a/tests/ui/parser/issues/issue-102182-impl-trait-recover.stderr
+++ b/tests/ui/parser/issues/issue-102182-impl-trait-recover.stderr
@@ -10,5 +10,5 @@ LL - fn foo<T: impl Trait>() {}
 LL + fn foo<T: Trait>() {}
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-103451.stderr b/tests/ui/parser/issues/issue-103451.stderr
index 6aacd5012c1..7ad816e451e 100644
--- a/tests/ui/parser/issues/issue-103451.stderr
+++ b/tests/ui/parser/issues/issue-103451.stderr
@@ -8,5 +8,5 @@ LL |     x: [u8; R
    |        |
    |        unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-10392-2.stderr b/tests/ui/parser/issues/issue-10392-2.stderr
index 4154ecfeb71..3e5d5062bee 100644
--- a/tests/ui/parser/issues/issue-10392-2.stderr
+++ b/tests/ui/parser/issues/issue-10392-2.stderr
@@ -8,5 +8,5 @@ LL |     let A { .., } = a();
    |             | help: remove this comma
    |             `..` must be at the end and cannot have a trailing comma
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-10392.stderr b/tests/ui/parser/issues/issue-10392.stderr
index 438ea67d33c..85090d054e8 100644
--- a/tests/ui/parser/issues/issue-10392.stderr
+++ b/tests/ui/parser/issues/issue-10392.stderr
@@ -6,5 +6,5 @@ LL |     let A { , } = a();
    |         |
    |         while parsing the fields for this pattern
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-104620.stderr b/tests/ui/parser/issues/issue-104620.stderr
index d06a6b2554b..fa20b5f8b16 100644
--- a/tests/ui/parser/issues/issue-104620.stderr
+++ b/tests/ui/parser/issues/issue-104620.stderr
@@ -4,5 +4,5 @@ error: unexpected expression: `5z`
 LL | #![rustc_dummy=5z]
    |                ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-105366.stderr b/tests/ui/parser/issues/issue-105366.stderr
index 0a7408e2c17..18c04dfaf20 100644
--- a/tests/ui/parser/issues/issue-105366.stderr
+++ b/tests/ui/parser/issues/issue-105366.stderr
@@ -9,5 +9,5 @@ help: replace `fn` with `impl` here
 LL | impl From<i32> for Foo {
    | ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-10636-1.stderr b/tests/ui/parser/issues/issue-10636-1.stderr
index 1e6294ebe16..a7402e0717b 100644
--- a/tests/ui/parser/issues/issue-10636-1.stderr
+++ b/tests/ui/parser/issues/issue-10636-1.stderr
@@ -7,5 +7,5 @@ LL | struct Obj {
 LL | )
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-10636-2.stderr b/tests/ui/parser/issues/issue-10636-2.stderr
index 4cd4be1803e..2dc615246a7 100644
--- a/tests/ui/parser/issues/issue-10636-2.stderr
+++ b/tests/ui/parser/issues/issue-10636-2.stderr
@@ -9,5 +9,5 @@ LL |     option.map(|some| 42;
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-107705.stderr b/tests/ui/parser/issues/issue-107705.stderr
index d2d61346118..2d0c3e0e675 100644
--- a/tests/ui/parser/issues/issue-107705.stderr
+++ b/tests/ui/parser/issues/issue-107705.stderr
@@ -6,5 +6,5 @@ LL | fn f() {a(b:&,
    |        |
    |        unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-108109-fn-trait-missing-paren.stderr b/tests/ui/parser/issues/issue-108109-fn-trait-missing-paren.stderr
index 7cda667570d..78017babbf6 100644
--- a/tests/ui/parser/issues/issue-108109-fn-trait-missing-paren.stderr
+++ b/tests/ui/parser/issues/issue-108109-fn-trait-missing-paren.stderr
@@ -7,5 +7,5 @@ LL | pub fn func<F>() where F: FnOnce -> () {}
    |                           |     help: try adding parentheses
    |                           `Fn` bounds require arguments in parentheses
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-108242-semicolon-recovery.stderr b/tests/ui/parser/issues/issue-108242-semicolon-recovery.stderr
index f68d6d5010d..e12283b25ad 100644
--- a/tests/ui/parser/issues/issue-108242-semicolon-recovery.stderr
+++ b/tests/ui/parser/issues/issue-108242-semicolon-recovery.stderr
@@ -9,5 +9,5 @@ LL |     foo(;
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-111148.stderr b/tests/ui/parser/issues/issue-111148.stderr
index e6595a5cbcc..bcfca981d25 100644
--- a/tests/ui/parser/issues/issue-111148.stderr
+++ b/tests/ui/parser/issues/issue-111148.stderr
@@ -4,5 +4,5 @@ error: expected one of `#`, `>`, `const`, identifier, or lifetime, found `<`
 LL | fn a<<i<Y<w<>#
    |      ^ expected one of `#`, `>`, `const`, identifier, or lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-111416.stderr b/tests/ui/parser/issues/issue-111416.stderr
index ddacf4d6dfc..36f6c5b018f 100644
--- a/tests/ui/parser/issues/issue-111416.stderr
+++ b/tests/ui/parser/issues/issue-111416.stderr
@@ -14,5 +14,5 @@ LL -     let my = monad_bind(mx, T: Try);
 LL +     let my = monad_bind(mx, Try);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-113110-non-item-at-module-root.stderr b/tests/ui/parser/issues/issue-113110-non-item-at-module-root.stderr
index 0789c4548a0..a47dd410369 100644
--- a/tests/ui/parser/issues/issue-113110-non-item-at-module-root.stderr
+++ b/tests/ui/parser/issues/issue-113110-non-item-at-module-root.stderr
@@ -6,5 +6,5 @@ LL |  5
    |
    = note: for a full list of items that can appear in modules, see <https://doc.rust-lang.org/reference/items.html>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-113203.stderr b/tests/ui/parser/issues/issue-113203.stderr
index 97304a89c9e..5db628d5977 100644
--- a/tests/ui/parser/issues/issue-113203.stderr
+++ b/tests/ui/parser/issues/issue-113203.stderr
@@ -4,5 +4,5 @@ error: incorrect use of `await`
 LL |     await {}()
    |     ^^^^^^^^ help: `await` is a postfix operation: `{}.await`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-113342.stderr b/tests/ui/parser/issues/issue-113342.stderr
index a0c5e665ff8..6d9f22f6a7c 100644
--- a/tests/ui/parser/issues/issue-113342.stderr
+++ b/tests/ui/parser/issues/issue-113342.stderr
@@ -7,5 +7,5 @@ LL | extern "C" pub fn id(x: i32) -> i32 { x }
    | |          expected `fn`
    | help: visibility `pub` must come before `extern "C"`: `pub extern "C"`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-114219.stderr b/tests/ui/parser/issues/issue-114219.stderr
index 90dcdc42775..02323cb99cb 100644
--- a/tests/ui/parser/issues/issue-114219.stderr
+++ b/tests/ui/parser/issues/issue-114219.stderr
@@ -4,5 +4,5 @@ error: `async move` blocks are only allowed in Rust 2018 or later
 LL |     async move {};
    |     ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-14303-fncall.full.stderr b/tests/ui/parser/issues/issue-14303-fncall.full.stderr
index 0c152516abc..1986f70bf67 100644
--- a/tests/ui/parser/issues/issue-14303-fncall.full.stderr
+++ b/tests/ui/parser/issues/issue-14303-fncall.full.stderr
@@ -4,6 +4,6 @@ error[E0747]: type provided when a lifetime was expected
 LL |         .collect::<Vec<S<_, 'a>>>();
    |                          ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/parser/issues/issue-14303-fncall.generic_arg.stderr b/tests/ui/parser/issues/issue-14303-fncall.generic_arg.stderr
index 57181577600..2de59b8c746 100644
--- a/tests/ui/parser/issues/issue-14303-fncall.generic_arg.stderr
+++ b/tests/ui/parser/issues/issue-14303-fncall.generic_arg.stderr
@@ -4,6 +4,6 @@ error[E0747]: inferred provided when a lifetime was expected
 LL |         .collect::<Vec<S<_, 'a>>>();
    |                          ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/ui/parser/issues/issue-15914.stderr b/tests/ui/parser/issues/issue-15914.stderr
index ea26453f808..c88fd4e55e2 100644
--- a/tests/ui/parser/issues/issue-15914.stderr
+++ b/tests/ui/parser/issues/issue-15914.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `(`
 LL |         ();
    |         ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-15980.stderr b/tests/ui/parser/issues/issue-15980.stderr
index cf8d0114787..c3c56c46a6d 100644
--- a/tests/ui/parser/issues/issue-15980.stderr
+++ b/tests/ui/parser/issues/issue-15980.stderr
@@ -16,5 +16,5 @@ help: you might have meant to start a match arm after the match guard
 LL |         Err(ref e) if e.kind == io::EndOfFile => {
    |                                               ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-1655.stderr b/tests/ui/parser/issues/issue-1655.stderr
index 0c390a0ec56..536b583aaa3 100644
--- a/tests/ui/parser/issues/issue-1655.stderr
+++ b/tests/ui/parser/issues/issue-1655.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `[`, found `vec`
 LL |     #vec[doc(
    |      ^^^ expected one of `!` or `[`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-17718-const-mut.stderr b/tests/ui/parser/issues/issue-17718-const-mut.stderr
index 8251ce9993f..a27f517086e 100644
--- a/tests/ui/parser/issues/issue-17718-const-mut.stderr
+++ b/tests/ui/parser/issues/issue-17718-const-mut.stderr
@@ -6,5 +6,5 @@ LL | const
 LL | mut
    | ^^^ cannot be mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-17904-2.stderr b/tests/ui/parser/issues/issue-17904-2.stderr
index 7185a5e5752..211ffcedd58 100644
--- a/tests/ui/parser/issues/issue-17904-2.stderr
+++ b/tests/ui/parser/issues/issue-17904-2.stderr
@@ -6,5 +6,5 @@ LL | struct Bar<T> { x: T } where T: Copy
    |
    = note: for a full list of items that can appear in modules, see <https://doc.rust-lang.org/reference/items.html>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-17904.stderr b/tests/ui/parser/issues/issue-17904.stderr
index aa343975dca..81c6e3bed1c 100644
--- a/tests/ui/parser/issues/issue-17904.stderr
+++ b/tests/ui/parser/issues/issue-17904.stderr
@@ -13,5 +13,5 @@ LL - struct Foo<T> where T: Copy, (T);
 LL + struct Foo<T>(T) where T: Copy;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-1802-1.stderr b/tests/ui/parser/issues/issue-1802-1.stderr
index 954cc0beeef..5ddc5ae58d9 100644
--- a/tests/ui/parser/issues/issue-1802-1.stderr
+++ b/tests/ui/parser/issues/issue-1802-1.stderr
@@ -4,6 +4,6 @@ error[E0768]: no valid digits found for number
 LL |     log(error, 0b);
    |                ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0768`.
diff --git a/tests/ui/parser/issues/issue-1802-2.stderr b/tests/ui/parser/issues/issue-1802-2.stderr
index 49043d07b35..7c802e4bdf7 100644
--- a/tests/ui/parser/issues/issue-1802-2.stderr
+++ b/tests/ui/parser/issues/issue-1802-2.stderr
@@ -4,6 +4,6 @@ error[E0768]: no valid digits found for number
 LL |     log(error, 0b);
    |                ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0768`.
diff --git a/tests/ui/parser/issues/issue-19398.stderr b/tests/ui/parser/issues/issue-19398.stderr
index 1da00960adf..236fac673b6 100644
--- a/tests/ui/parser/issues/issue-19398.stderr
+++ b/tests/ui/parser/issues/issue-19398.stderr
@@ -9,5 +9,5 @@ LL |
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-1.stderr b/tests/ui/parser/issues/issue-20616-1.stderr
index 81604623785..b7a8d22d8ff 100644
--- a/tests/ui/parser/issues/issue-20616-1.stderr
+++ b/tests/ui/parser/issues/issue-20616-1.stderr
@@ -4,5 +4,5 @@ error: expected one of `,`, `:`, or `>`, found `T`
 LL | type Type_1<'a T> = &'a T;
    |                ^ expected one of `,`, `:`, or `>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-2.stderr b/tests/ui/parser/issues/issue-20616-2.stderr
index 42059685c5c..038b2ffc72b 100644
--- a/tests/ui/parser/issues/issue-20616-2.stderr
+++ b/tests/ui/parser/issues/issue-20616-2.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type Type_2 = Type_1_<'static> ()>;
    |                              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-3.stderr b/tests/ui/parser/issues/issue-20616-3.stderr
index dbff116e505..10e5befe2a7 100644
--- a/tests/ui/parser/issues/issue-20616-3.stderr
+++ b/tests/ui/parser/issues/issue-20616-3.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type Type_3<T> = Box<T>,,>;
    |                       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-4.stderr b/tests/ui/parser/issues/issue-20616-4.stderr
index 48a06e00b24..df619b4c79b 100644
--- a/tests/ui/parser/issues/issue-20616-4.stderr
+++ b/tests/ui/parser/issues/issue-20616-4.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type Type_4<T> = Type_1_<'static>,, T>;
    |                                 +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-5.stderr b/tests/ui/parser/issues/issue-20616-5.stderr
index 84bee2ad184..709a5467def 100644
--- a/tests/ui/parser/issues/issue-20616-5.stderr
+++ b/tests/ui/parser/issues/issue-20616-5.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type Type_5<'a> = Type_1_<'a, ()>,,>;
    |                                 +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-6.stderr b/tests/ui/parser/issues/issue-20616-6.stderr
index 67de41b9747..7fe1f1c456f 100644
--- a/tests/ui/parser/issues/issue-20616-6.stderr
+++ b/tests/ui/parser/issues/issue-20616-6.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type Type_6 = Type_5_<'a>,,>;
    |                         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-7.stderr b/tests/ui/parser/issues/issue-20616-7.stderr
index 3b8e07fa0d0..d9e97301f5d 100644
--- a/tests/ui/parser/issues/issue-20616-7.stderr
+++ b/tests/ui/parser/issues/issue-20616-7.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type Type_7 = Box<()>,,>;
    |                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-8.stderr b/tests/ui/parser/issues/issue-20616-8.stderr
index e9f37e50fff..f8d7dc63c94 100644
--- a/tests/ui/parser/issues/issue-20616-8.stderr
+++ b/tests/ui/parser/issues/issue-20616-8.stderr
@@ -4,5 +4,5 @@ error: expected one of `#`, `>`, `const`, identifier, or lifetime, found `,`
 LL | type Type_8<'a,,> = &'a ();
    |                ^ expected one of `#`, `>`, `const`, identifier, or lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20616-9.stderr b/tests/ui/parser/issues/issue-20616-9.stderr
index dc309d1bce1..5dccacdb610 100644
--- a/tests/ui/parser/issues/issue-20616-9.stderr
+++ b/tests/ui/parser/issues/issue-20616-9.stderr
@@ -4,5 +4,5 @@ error: expected one of `#`, `>`, `const`, identifier, or lifetime, found `,`
 LL | type Type_9<T,,> = Box<T>;
    |               ^ expected one of `#`, `>`, `const`, identifier, or lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20711-2.stderr b/tests/ui/parser/issues/issue-20711-2.stderr
index 12b18bbc594..9fb7298955b 100644
--- a/tests/ui/parser/issues/issue-20711-2.stderr
+++ b/tests/ui/parser/issues/issue-20711-2.stderr
@@ -10,5 +10,5 @@ LL |
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-20711.stderr b/tests/ui/parser/issues/issue-20711.stderr
index 4af4b22bee2..256fb0ade72 100644
--- a/tests/ui/parser/issues/issue-20711.stderr
+++ b/tests/ui/parser/issues/issue-20711.stderr
@@ -9,5 +9,5 @@ LL |
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-21146.stderr b/tests/ui/parser/issues/issue-21146.stderr
index c71fda3d63f..e83c62afe79 100644
--- a/tests/ui/parser/issues/issue-21146.stderr
+++ b/tests/ui/parser/issues/issue-21146.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `::`, found `<eof>`
 LL | parse_error
    | ^^^^^^^^^^^ expected one of `!` or `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-21153.stderr b/tests/ui/parser/issues/issue-21153.stderr
index cbfa9ded3c3..8839eed8485 100644
--- a/tests/ui/parser/issues/issue-21153.stderr
+++ b/tests/ui/parser/issues/issue-21153.stderr
@@ -9,5 +9,5 @@ LL |
 LL | }
    | - the item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-22647.stderr b/tests/ui/parser/issues/issue-22647.stderr
index 585e7026661..bdf74af6393 100644
--- a/tests/ui/parser/issues/issue-22647.stderr
+++ b/tests/ui/parser/issues/issue-22647.stderr
@@ -9,5 +9,5 @@ help: use `::<...>` instead of `<...>` to specify lifetime, type, or const argum
 LL |     let caller::<F> = |f: F|
    |               ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-22712.stderr b/tests/ui/parser/issues/issue-22712.stderr
index 7f9d99d8edf..aeca95ed68e 100644
--- a/tests/ui/parser/issues/issue-22712.stderr
+++ b/tests/ui/parser/issues/issue-22712.stderr
@@ -9,5 +9,5 @@ help: use `::<...>` instead of `<...>` to specify lifetime, type, or const argum
 LL |     let Foo::<Vec<u8>>
    |            ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-2354-1.stderr b/tests/ui/parser/issues/issue-2354-1.stderr
index 7ea0f2a9828..edd64ecf31e 100644
--- a/tests/ui/parser/issues/issue-2354-1.stderr
+++ b/tests/ui/parser/issues/issue-2354-1.stderr
@@ -4,5 +4,5 @@ error: unexpected closing delimiter: `}`
 LL | static foo: isize = 2; }
    |                        ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-2354.stderr b/tests/ui/parser/issues/issue-2354.stderr
index b89ed395835..fd649a575c6 100644
--- a/tests/ui/parser/issues/issue-2354.stderr
+++ b/tests/ui/parser/issues/issue-2354.stderr
@@ -12,5 +12,5 @@ LL | }
 LL |
    |                                                    ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-24197.stderr b/tests/ui/parser/issues/issue-24197.stderr
index fd7015ccd39..3ef707f3953 100644
--- a/tests/ui/parser/issues/issue-24197.stderr
+++ b/tests/ui/parser/issues/issue-24197.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
 LL |     let buf[0] = 0;
    |            ^ expected one of `:`, `;`, `=`, `@`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-24375.stderr b/tests/ui/parser/issues/issue-24375.stderr
index 7aed88768a0..bb1e19e9e6d 100644
--- a/tests/ui/parser/issues/issue-24375.stderr
+++ b/tests/ui/parser/issues/issue-24375.stderr
@@ -4,5 +4,5 @@ error: expected one of `=>`, `@`, `if`, or `|`, found `[`
 LL |         tmp[0] => {}
    |            ^ expected one of `=>`, `@`, `if`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-24780.stderr b/tests/ui/parser/issues/issue-24780.stderr
index d9470191b25..43e20010225 100644
--- a/tests/ui/parser/issues/issue-24780.stderr
+++ b/tests/ui/parser/issues/issue-24780.stderr
@@ -4,5 +4,5 @@ error: expected one of `!`, `+`, `::`, `where`, or `{`, found `>`
 LL | fn foo() -> Vec<usize>> {
    |                       ^ expected one of `!`, `+`, `::`, `where`, or `{`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-3036.stderr b/tests/ui/parser/issues/issue-3036.stderr
index e02223931c1..3dd89b7e828 100644
--- a/tests/ui/parser/issues/issue-3036.stderr
+++ b/tests/ui/parser/issues/issue-3036.stderr
@@ -6,5 +6,5 @@ LL |     let _x = 3
 LL | }
    | - unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-31804.stderr b/tests/ui/parser/issues/issue-31804.stderr
index 76e68b0b352..d3d2c2a0f9e 100644
--- a/tests/ui/parser/issues/issue-31804.stderr
+++ b/tests/ui/parser/issues/issue-31804.stderr
@@ -4,5 +4,5 @@ error: expected pattern, found `}`
 LL | }
    | ^ expected pattern
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-32214.stderr b/tests/ui/parser/issues/issue-32214.stderr
index d0a9b529983..2ef4305dfd0 100644
--- a/tests/ui/parser/issues/issue-32214.stderr
+++ b/tests/ui/parser/issues/issue-32214.stderr
@@ -11,5 +11,5 @@ help: move the constraint after the generic argument
 LL | pub fn test<W, I: Trait<W, Item = ()> >() {}
    |                        ~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-32446.stderr b/tests/ui/parser/issues/issue-32446.stderr
index 7515369aaa0..7319e839b93 100644
--- a/tests/ui/parser/issues/issue-32446.stderr
+++ b/tests/ui/parser/issues/issue-32446.stderr
@@ -7,5 +7,5 @@ LL | trait T { ... }
    |         | non-item starts here
    |         item list starts here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-32501.stderr b/tests/ui/parser/issues/issue-32501.stderr
index df12f7768d4..c0513a64039 100644
--- a/tests/ui/parser/issues/issue-32501.stderr
+++ b/tests/ui/parser/issues/issue-32501.stderr
@@ -6,5 +6,5 @@ LL |     let mut _ = 0;
    |
    = note: `mut` may be followed by `variable` and `variable @ pattern`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-33262.stderr b/tests/ui/parser/issues/issue-33262.stderr
index 2aff3283935..ec4934eb722 100644
--- a/tests/ui/parser/issues/issue-33262.stderr
+++ b/tests/ui/parser/issues/issue-33262.stderr
@@ -4,5 +4,5 @@ error: expected type, found `{`
 LL |     for i in 0..a as { }
    |                      ^ expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-33455.stderr b/tests/ui/parser/issues/issue-33455.stderr
index c535ef23b22..573614a5e99 100644
--- a/tests/ui/parser/issues/issue-33455.stderr
+++ b/tests/ui/parser/issues/issue-33455.stderr
@@ -4,5 +4,5 @@ error: expected one of `::`, `;`, or `as`, found `.`
 LL | use foo.bar;
    |        ^ expected one of `::`, `;`, or `as`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-34222-1.stderr b/tests/ui/parser/issues/issue-34222-1.stderr
index b451484ba22..b2a6ae93a45 100644
--- a/tests/ui/parser/issues/issue-34222-1.stderr
+++ b/tests/ui/parser/issues/issue-34222-1.stderr
@@ -6,6 +6,6 @@ LL |     /// comment
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/issues/issue-34255-1.stderr b/tests/ui/parser/issues/issue-34255-1.stderr
index 0e2b0d62ef6..1e72f040b03 100644
--- a/tests/ui/parser/issues/issue-34255-1.stderr
+++ b/tests/ui/parser/issues/issue-34255-1.stderr
@@ -14,5 +14,5 @@ LL -     Test::Drill(field: 42);
 LL +     Test::Drill(42);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-39616.stderr b/tests/ui/parser/issues/issue-39616.stderr
index 393d1f2e2ce..da85bcb446c 100644
--- a/tests/ui/parser/issues/issue-39616.stderr
+++ b/tests/ui/parser/issues/issue-39616.stderr
@@ -4,5 +4,5 @@ error: expected type, found `0`
 LL | fn foo(a: [0; 1]) {}
    |            ^ expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-43692.stderr b/tests/ui/parser/issues/issue-43692.stderr
index baf99803517..1ce3aa67135 100644
--- a/tests/ui/parser/issues/issue-43692.stderr
+++ b/tests/ui/parser/issues/issue-43692.stderr
@@ -4,5 +4,5 @@ error: invalid start of unicode escape: `_`
 LL |     '\u{_10FFFF}';
    |         ^ invalid start of unicode escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-44021.stderr b/tests/ui/parser/issues/issue-44021.stderr
index b888cd989a6..8a9326f90c6 100644
--- a/tests/ui/parser/issues/issue-44021.stderr
+++ b/tests/ui/parser/issues/issue-44021.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `@`, or `|`, found `}`
 LL |     fn f() {|x, y}
    |                  ^ expected one of `:`, `@`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-44406.stderr b/tests/ui/parser/issues/issue-44406.stderr
index 69ff64c2772..d005f116e12 100644
--- a/tests/ui/parser/issues/issue-44406.stderr
+++ b/tests/ui/parser/issues/issue-44406.stderr
@@ -18,5 +18,5 @@ LL -         bar(baz: $rest)
 LL +         bar(: $rest)
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-45296.stderr b/tests/ui/parser/issues/issue-45296.stderr
index 081a72054e8..1d2281df108 100644
--- a/tests/ui/parser/issues/issue-45296.stderr
+++ b/tests/ui/parser/issues/issue-45296.stderr
@@ -13,5 +13,5 @@ LL -     #![allow(unused_variables)]
 LL +     #[allow(unused_variables)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-46186.stderr b/tests/ui/parser/issues/issue-46186.stderr
index 0766c8a33df..c67c271e19a 100644
--- a/tests/ui/parser/issues/issue-46186.stderr
+++ b/tests/ui/parser/issues/issue-46186.stderr
@@ -6,5 +6,5 @@ LL | };
    |
    = help: braced struct declarations are not followed by a semicolon
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-48636.stderr b/tests/ui/parser/issues/issue-48636.stderr
index 6177870d1ce..488a046a549 100644
--- a/tests/ui/parser/issues/issue-48636.stderr
+++ b/tests/ui/parser/issues/issue-48636.stderr
@@ -10,6 +10,6 @@ LL |     /// The ID of the parent core
    |
    = help: doc comments must come before what they document, if a comment was intended use `//`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0585`.
diff --git a/tests/ui/parser/issues/issue-51602.stderr b/tests/ui/parser/issues/issue-51602.stderr
index 4a5653fdb51..7b50e0ad0fa 100644
--- a/tests/ui/parser/issues/issue-51602.stderr
+++ b/tests/ui/parser/issues/issue-51602.stderr
@@ -10,5 +10,5 @@ note: the `if` expression is missing a block after this condition
 LL |     if i in 1..10 {
    |        ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-5544-a.stderr b/tests/ui/parser/issues/issue-5544-a.stderr
index 6e68c75850a..aeb13460092 100644
--- a/tests/ui/parser/issues/issue-5544-a.stderr
+++ b/tests/ui/parser/issues/issue-5544-a.stderr
@@ -6,5 +6,5 @@ LL |     let __isize = 340282366920938463463374607431768211456; // 2^128
    |
    = note: value exceeds limit of `340282366920938463463374607431768211455`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-5544-b.stderr b/tests/ui/parser/issues/issue-5544-b.stderr
index 5d0e76d5d94..65e6f196b09 100644
--- a/tests/ui/parser/issues/issue-5544-b.stderr
+++ b/tests/ui/parser/issues/issue-5544-b.stderr
@@ -6,5 +6,5 @@ LL |     let __isize = 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff_ff;
    |
    = note: value exceeds limit of `0xffffffffffffffffffffffffffffffff`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-56031.stderr b/tests/ui/parser/issues/issue-56031.stderr
index 2fa05dd2dfb..8031bf82fd1 100644
--- a/tests/ui/parser/issues/issue-56031.stderr
+++ b/tests/ui/parser/issues/issue-56031.stderr
@@ -14,5 +14,5 @@ LL - impl for T {}
 LL + impl T {}
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-57198.stderr b/tests/ui/parser/issues/issue-57198.stderr
index dd70b40224c..dca0d3ea486 100644
--- a/tests/ui/parser/issues/issue-57198.stderr
+++ b/tests/ui/parser/issues/issue-57198.stderr
@@ -9,5 +9,5 @@ help: escape `for` to use it as an identifier
 LL |     m::r#for();
    |        ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-5806.stderr b/tests/ui/parser/issues/issue-5806.stderr
index bdb5c91ff91..4b025bd19a0 100644
--- a/tests/ui/parser/issues/issue-5806.stderr
+++ b/tests/ui/parser/issues/issue-5806.stderr
@@ -4,5 +4,5 @@ error: couldn't read $DIR/../parser: $ACCESS_DENIED_MSG (os error $ACCESS_DENIED
 LL | mod foo;
    | ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
index a596a9f2de3..a2ea8ad368b 100644
--- a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
+++ b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
@@ -1,5 +1,5 @@
 // Fixed in #66054.
 // ignore-tidy-trailing-newlines
 // error-pattern: this file contains an unclosed delimiter
-// error-pattern: aborting due to previous error
+// error-pattern: aborting due to 1 previous error
 #[Ѕ
\ No newline at end of file
diff --git a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
index c79e8b4fb70..14f5469f6af 100644
--- a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
+++ b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
@@ -6,5 +6,5 @@ LL | #[Ѕ
    |  |
    |  unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-58856-1.stderr b/tests/ui/parser/issues/issue-58856-1.stderr
index 77ad8acbd43..2c333439197 100644
--- a/tests/ui/parser/issues/issue-58856-1.stderr
+++ b/tests/ui/parser/issues/issue-58856-1.stderr
@@ -8,5 +8,5 @@ LL |     fn b(self>
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-58856-2.stderr b/tests/ui/parser/issues/issue-58856-2.stderr
index 5fcf5bcc17e..d3255fca021 100644
--- a/tests/ui/parser/issues/issue-58856-2.stderr
+++ b/tests/ui/parser/issues/issue-58856-2.stderr
@@ -9,5 +9,5 @@ LL |     fn how_are_you(&self -> Empty {
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-60075.stderr b/tests/ui/parser/issues/issue-60075.stderr
index cd8f1231fad..b40412aba55 100644
--- a/tests/ui/parser/issues/issue-60075.stderr
+++ b/tests/ui/parser/issues/issue-60075.stderr
@@ -7,5 +7,5 @@ LL |         let _ = if true {
 LL |         });
    |          ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-61858.stderr b/tests/ui/parser/issues/issue-61858.stderr
index 03f51c6e3a8..6bdfec9384e 100644
--- a/tests/ui/parser/issues/issue-61858.stderr
+++ b/tests/ui/parser/issues/issue-61858.stderr
@@ -10,5 +10,5 @@ note: the `if` expression is missing a block after this condition
 LL |     (if foobar)
    |         ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-62524.rs b/tests/ui/parser/issues/issue-62524.rs
index fa7c626f5cc..dd86fc9a7f8 100644
--- a/tests/ui/parser/issues/issue-62524.rs
+++ b/tests/ui/parser/issues/issue-62524.rs
@@ -1,5 +1,5 @@
 // ignore-tidy-trailing-newlines
-// error-pattern: aborting due to previous error
+// error-pattern: aborting due to 1 previous error
 #![allow(uncommon_codepoints)]
 
 y![
diff --git a/tests/ui/parser/issues/issue-62524.stderr b/tests/ui/parser/issues/issue-62524.stderr
index 0cbaacd4c64..d83a49aedd6 100644
--- a/tests/ui/parser/issues/issue-62524.stderr
+++ b/tests/ui/parser/issues/issue-62524.stderr
@@ -6,5 +6,5 @@ LL | y![
 LL | Ϥ,
    |   ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-62546.stderr b/tests/ui/parser/issues/issue-62546.stderr
index 80c1c71689d..6889cb3b8e9 100644
--- a/tests/ui/parser/issues/issue-62546.stderr
+++ b/tests/ui/parser/issues/issue-62546.stderr
@@ -4,5 +4,5 @@ error: this file contains an unclosed delimiter
 LL | pub t(#
    |      - unclosed delimiter                                  ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-62554.stderr b/tests/ui/parser/issues/issue-62554.stderr
index 4637c795ae5..37314dd39c7 100644
--- a/tests/ui/parser/issues/issue-62554.stderr
+++ b/tests/ui/parser/issues/issue-62554.stderr
@@ -9,5 +9,5 @@ LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s
    |               |                       |         unclosed delimiter
    |               unclosed delimiter      unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-62660.stderr b/tests/ui/parser/issues/issue-62660.stderr
index 14c0bdcb111..310b433f2df 100644
--- a/tests/ui/parser/issues/issue-62660.stderr
+++ b/tests/ui/parser/issues/issue-62660.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL |     pub fn foo(_: i32, self: Box<Self>) {}
    |                                      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-62881.stderr b/tests/ui/parser/issues/issue-62881.stderr
index e57cbd1810a..2165a81a048 100644
--- a/tests/ui/parser/issues/issue-62881.stderr
+++ b/tests/ui/parser/issues/issue-62881.stderr
@@ -4,5 +4,5 @@ error: this file contains an unclosed delimiter
 LL | fn f() -> isize { fn f() -> isize {} pub f<
    |                 - unclosed delimiter                                                           ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-62894.stderr b/tests/ui/parser/issues/issue-62894.stderr
index 700479076df..870633fc96f 100644
--- a/tests/ui/parser/issues/issue-62894.stderr
+++ b/tests/ui/parser/issues/issue-62894.stderr
@@ -10,5 +10,5 @@ LL |
 LL | fn main() {}
    |              ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-63135.rs b/tests/ui/parser/issues/issue-63135.rs
index d61197dc566..2e1ac080bc5 100644
--- a/tests/ui/parser/issues/issue-63135.rs
+++ b/tests/ui/parser/issues/issue-63135.rs
@@ -1,3 +1,3 @@
 // error-pattern: this file contains an unclosed delimiter
-// error-pattern: aborting due to previous error
+// error-pattern: aborting due to 1 previous error
 fn i(n{...,f #
diff --git a/tests/ui/parser/issues/issue-63135.stderr b/tests/ui/parser/issues/issue-63135.stderr
index ff9d99c28fe..9204f561e96 100644
--- a/tests/ui/parser/issues/issue-63135.stderr
+++ b/tests/ui/parser/issues/issue-63135.stderr
@@ -7,5 +7,5 @@ LL | fn i(n{...,f #
    |     | unclosed delimiter
    |     unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-6610.stderr b/tests/ui/parser/issues/issue-6610.stderr
index 4a3bc752553..83fc029967c 100644
--- a/tests/ui/parser/issues/issue-6610.stderr
+++ b/tests/ui/parser/issues/issue-6610.stderr
@@ -6,5 +6,5 @@ LL | trait Foo { fn a() }
    |                |
    |                while parsing this `fn`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-66357-unexpected-unreachable.stderr b/tests/ui/parser/issues/issue-66357-unexpected-unreachable.stderr
index 079fff37ea4..a265cbf70a6 100644
--- a/tests/ui/parser/issues/issue-66357-unexpected-unreachable.stderr
+++ b/tests/ui/parser/issues/issue-66357-unexpected-unreachable.stderr
@@ -7,5 +7,5 @@ LL | fn f() { |[](* }
    |        |    unclosed delimiter
    |        closing delimiter possibly meant for this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-68091-unicode-ident-after-if.stderr b/tests/ui/parser/issues/issue-68091-unicode-ident-after-if.stderr
index 6674b924e9c..2423a7526be 100644
--- a/tests/ui/parser/issues/issue-68091-unicode-ident-after-if.stderr
+++ b/tests/ui/parser/issues/issue-68091-unicode-ident-after-if.stderr
@@ -6,5 +6,5 @@ LL |         $($c)ö* {}
    |              |
    |              expected condition here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-68092-unicode-ident-after-incomplete-expr.stderr b/tests/ui/parser/issues/issue-68092-unicode-ident-after-incomplete-expr.stderr
index 0b9c364f1f1..43047ff8802 100644
--- a/tests/ui/parser/issues/issue-68092-unicode-ident-after-incomplete-expr.stderr
+++ b/tests/ui/parser/issues/issue-68092-unicode-ident-after-incomplete-expr.stderr
@@ -4,5 +4,5 @@ error: macro expansion ends with an incomplete expression: expected expression
 LL |         $($c)ö*
    |              ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-68987-unmatch-issue-1.stderr b/tests/ui/parser/issues/issue-68987-unmatch-issue-1.stderr
index 2d873b46193..5b5d45a7e87 100644
--- a/tests/ui/parser/issues/issue-68987-unmatch-issue-1.stderr
+++ b/tests/ui/parser/issues/issue-68987-unmatch-issue-1.stderr
@@ -12,5 +12,5 @@ LL |         }
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-68987-unmatch-issue.stderr b/tests/ui/parser/issues/issue-68987-unmatch-issue.stderr
index cabd133242f..782b85f0940 100644
--- a/tests/ui/parser/issues/issue-68987-unmatch-issue.stderr
+++ b/tests/ui/parser/issues/issue-68987-unmatch-issue.stderr
@@ -12,5 +12,5 @@ LL |         }
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-69259.stderr b/tests/ui/parser/issues/issue-69259.stderr
index 604b7de3319..a8487b5f4be 100644
--- a/tests/ui/parser/issues/issue-69259.stderr
+++ b/tests/ui/parser/issues/issue-69259.stderr
@@ -4,5 +4,5 @@ error: unexpected closing delimiter: `)`
 LL | fn f) {}
    |     ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-70552-ascription-in-parens-after-call.stderr b/tests/ui/parser/issues/issue-70552-ascription-in-parens-after-call.stderr
index f03c92e1b1f..14cf52ce672 100644
--- a/tests/ui/parser/issues/issue-70552-ascription-in-parens-after-call.stderr
+++ b/tests/ui/parser/issues/issue-70552-ascription-in-parens-after-call.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `:`
 LL |     expr as fun()(:);
    |                   ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-70583-block-is-empty-1.stderr b/tests/ui/parser/issues/issue-70583-block-is-empty-1.stderr
index 46cbb056d1d..c4621b2b84a 100644
--- a/tests/ui/parser/issues/issue-70583-block-is-empty-1.stderr
+++ b/tests/ui/parser/issues/issue-70583-block-is-empty-1.stderr
@@ -9,5 +9,5 @@ LL |     }
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-70583-block-is-empty-2.stderr b/tests/ui/parser/issues/issue-70583-block-is-empty-2.stderr
index c590e04bb3d..a21cd4875f6 100644
--- a/tests/ui/parser/issues/issue-70583-block-is-empty-2.stderr
+++ b/tests/ui/parser/issues/issue-70583-block-is-empty-2.stderr
@@ -12,5 +12,5 @@ LL |             ErrorHandled::Reported => {}}
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-72253.stderr b/tests/ui/parser/issues/issue-72253.stderr
index 477fa09f495..c4fc662f5d9 100644
--- a/tests/ui/parser/issues/issue-72253.stderr
+++ b/tests/ui/parser/issues/issue-72253.stderr
@@ -6,5 +6,5 @@ LL |         .arg("1")
 LL |         ,arg("2")
    |         ^ unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-72373.stderr b/tests/ui/parser/issues/issue-72373.stderr
index 0bb99a01e55..c596c6abda5 100644
--- a/tests/ui/parser/issues/issue-72373.stderr
+++ b/tests/ui/parser/issues/issue-72373.stderr
@@ -9,5 +9,5 @@ help: if you meant to bind the contents of the rest of the array pattern into `t
 LL |         [h, ref ts @ ..] => foo(c, n - h) + foo(ts, n),
    |                    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76437-async.stderr b/tests/ui/parser/issues/issue-76437-async.stderr
index 2c9c2a8cfba..7f2df5c8736 100644
--- a/tests/ui/parser/issues/issue-76437-async.stderr
+++ b/tests/ui/parser/issues/issue-76437-async.stderr
@@ -7,5 +7,5 @@ LL |     async pub fn t() {}
    |     |     expected one of `extern`, `fn`, or `unsafe`
    |     help: visibility `pub` must come before `async`: `pub async`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76437-const-async-unsafe.stderr b/tests/ui/parser/issues/issue-76437-const-async-unsafe.stderr
index 2e91beda116..a703fc4e8a4 100644
--- a/tests/ui/parser/issues/issue-76437-const-async-unsafe.stderr
+++ b/tests/ui/parser/issues/issue-76437-const-async-unsafe.stderr
@@ -7,5 +7,5 @@ LL |     const async unsafe pub fn t() {}
    |     |                  expected one of `extern` or `fn`
    |     help: visibility `pub` must come before `const async unsafe`: `pub const async unsafe`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76437-const-async.stderr b/tests/ui/parser/issues/issue-76437-const-async.stderr
index 21b96c14d7d..a9acccdce18 100644
--- a/tests/ui/parser/issues/issue-76437-const-async.stderr
+++ b/tests/ui/parser/issues/issue-76437-const-async.stderr
@@ -7,5 +7,5 @@ LL |     const async pub fn t() {}
    |     |           expected one of `extern`, `fn`, or `unsafe`
    |     help: visibility `pub` must come before `const async`: `pub const async`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76437-const.stderr b/tests/ui/parser/issues/issue-76437-const.stderr
index cf80d9a9037..4c36d773d60 100644
--- a/tests/ui/parser/issues/issue-76437-const.stderr
+++ b/tests/ui/parser/issues/issue-76437-const.stderr
@@ -7,5 +7,5 @@ LL |     const pub fn t() {}
    |     |     expected one of `async`, `extern`, `fn`, or `unsafe`
    |     help: visibility `pub` must come before `const`: `pub const`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76437-pub-crate-unsafe.stderr b/tests/ui/parser/issues/issue-76437-pub-crate-unsafe.stderr
index fa8f13721c8..4ea76179be3 100644
--- a/tests/ui/parser/issues/issue-76437-pub-crate-unsafe.stderr
+++ b/tests/ui/parser/issues/issue-76437-pub-crate-unsafe.stderr
@@ -7,5 +7,5 @@ LL |     unsafe pub(crate) fn t() {}
    |     |      expected one of `extern` or `fn`
    |     help: visibility `pub(crate)` must come before `unsafe`: `pub(crate) unsafe`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76437-unsafe.stderr b/tests/ui/parser/issues/issue-76437-unsafe.stderr
index c63292ef853..69f7927750b 100644
--- a/tests/ui/parser/issues/issue-76437-unsafe.stderr
+++ b/tests/ui/parser/issues/issue-76437-unsafe.stderr
@@ -7,5 +7,5 @@ LL |     unsafe pub fn t() {}
    |     |      expected one of `extern` or `fn`
    |     help: visibility `pub` must come before `unsafe`: `pub unsafe`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-76597.stderr b/tests/ui/parser/issues/issue-76597.stderr
index 50b23329f0c..25858981cff 100644
--- a/tests/ui/parser/issues/issue-76597.stderr
+++ b/tests/ui/parser/issues/issue-76597.stderr
@@ -9,5 +9,5 @@ LL | ...                   x: u8
 LL | ...                   y: u8,
    |                       ^ unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-7970b.stderr b/tests/ui/parser/issues/issue-7970b.stderr
index a62226a8a4d..b23b09e752c 100644
--- a/tests/ui/parser/issues/issue-7970b.stderr
+++ b/tests/ui/parser/issues/issue-7970b.stderr
@@ -4,5 +4,5 @@ error: unexpected end of macro invocation
 LL | macro_rules! test {}
    | ^^^^^^^^^^^^^^^^^^^^ missing tokens in macro arguments
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-81806.stderr b/tests/ui/parser/issues/issue-81806.stderr
index 40873388dfb..f1287b82fa5 100644
--- a/tests/ui/parser/issues/issue-81806.stderr
+++ b/tests/ui/parser/issues/issue-81806.stderr
@@ -13,5 +13,5 @@ help: escape `impl` to use it as an identifier
 LL | r#impl
    | ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-83639.stderr b/tests/ui/parser/issues/issue-83639.stderr
index 4c10df1917c..87218a4487b 100644
--- a/tests/ui/parser/issues/issue-83639.stderr
+++ b/tests/ui/parser/issues/issue-83639.stderr
@@ -4,5 +4,5 @@ error: expected one of `.`, `;`, `?`, `}`, or an operator, found `"    "`
 LL |     """    "
    |       ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-84104.stderr b/tests/ui/parser/issues/issue-84104.stderr
index 7ad59f8450e..e866d392267 100644
--- a/tests/ui/parser/issues/issue-84104.stderr
+++ b/tests/ui/parser/issues/issue-84104.stderr
@@ -6,5 +6,5 @@ LL | #[i=i::<ښܖ<
    |  |
    |  unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-84148-2.stderr b/tests/ui/parser/issues/issue-84148-2.stderr
index 20761180e77..d9b6b336a2c 100644
--- a/tests/ui/parser/issues/issue-84148-2.stderr
+++ b/tests/ui/parser/issues/issue-84148-2.stderr
@@ -6,5 +6,5 @@ LL | fn f(t:for<>t?
    |     |
    |     unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-8537.stderr b/tests/ui/parser/issues/issue-8537.stderr
index 523cc9dc588..0d636bd28a5 100644
--- a/tests/ui/parser/issues/issue-8537.stderr
+++ b/tests/ui/parser/issues/issue-8537.stderr
@@ -6,6 +6,6 @@ LL |   "invalid-ab_isize"
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0703`.
diff --git a/tests/ui/parser/issues/issue-86895.stderr b/tests/ui/parser/issues/issue-86895.stderr
index 575d857c0ed..dcde7242d39 100644
--- a/tests/ui/parser/issues/issue-86895.stderr
+++ b/tests/ui/parser/issues/issue-86895.stderr
@@ -4,5 +4,5 @@ error: expected one of `async`, `extern`, `fn`, or `unsafe`, found keyword `pub`
 LL | const pub () {}
    |       ^^^ expected one of `async`, `extern`, `fn`, or `unsafe`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-87217-keyword-order/wrong-async.stderr b/tests/ui/parser/issues/issue-87217-keyword-order/wrong-async.stderr
index e9eb14bf00e..74989502e7f 100644
--- a/tests/ui/parser/issues/issue-87217-keyword-order/wrong-async.stderr
+++ b/tests/ui/parser/issues/issue-87217-keyword-order/wrong-async.stderr
@@ -9,5 +9,5 @@ LL | unsafe async fn test() {}
    |
    = note: keyword order for functions declaration is `pub`, `default`, `const`, `async`, `unsafe`, `extern`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-87217-keyword-order/wrong-const.stderr b/tests/ui/parser/issues/issue-87217-keyword-order/wrong-const.stderr
index 0d2bc347296..5958f0c7d2d 100644
--- a/tests/ui/parser/issues/issue-87217-keyword-order/wrong-const.stderr
+++ b/tests/ui/parser/issues/issue-87217-keyword-order/wrong-const.stderr
@@ -9,5 +9,5 @@ LL | unsafe const fn test() {}
    |
    = note: keyword order for functions declaration is `pub`, `default`, `const`, `async`, `unsafe`, `extern`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-87217-keyword-order/wrong-unsafe.stderr b/tests/ui/parser/issues/issue-87217-keyword-order/wrong-unsafe.stderr
index 4224713ccb5..0e9f7c51e1a 100644
--- a/tests/ui/parser/issues/issue-87217-keyword-order/wrong-unsafe.stderr
+++ b/tests/ui/parser/issues/issue-87217-keyword-order/wrong-unsafe.stderr
@@ -9,5 +9,5 @@ LL | extern unsafe fn test() {}
    |
    = note: keyword order for functions declaration is `pub`, `default`, `const`, `async`, `unsafe`, `extern`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-87694-duplicated-pub.stderr b/tests/ui/parser/issues/issue-87694-duplicated-pub.stderr
index 8d242bc9de5..a210238652a 100644
--- a/tests/ui/parser/issues/issue-87694-duplicated-pub.stderr
+++ b/tests/ui/parser/issues/issue-87694-duplicated-pub.stderr
@@ -13,5 +13,5 @@ note: explicit visibility first seen here
 LL | pub const pub fn test() {}
    | ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-87694-misplaced-pub.stderr b/tests/ui/parser/issues/issue-87694-misplaced-pub.stderr
index 94c6a29efcb..6f686a7e504 100644
--- a/tests/ui/parser/issues/issue-87694-misplaced-pub.stderr
+++ b/tests/ui/parser/issues/issue-87694-misplaced-pub.stderr
@@ -7,5 +7,5 @@ LL | const pub fn test() {}
    | |     expected one of `async`, `extern`, `fn`, or `unsafe`
    | help: visibility `pub` must come before `const`: `pub const`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-87812-path.stderr b/tests/ui/parser/issues/issue-87812-path.stderr
index d045f4821ff..fbe26ea3959 100644
--- a/tests/ui/parser/issues/issue-87812-path.stderr
+++ b/tests/ui/parser/issues/issue-87812-path.stderr
@@ -11,6 +11,6 @@ LL |     foo!(Baz);
    |
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/parser/issues/issue-87812.stderr b/tests/ui/parser/issues/issue-87812.stderr
index d61ee23a50b..35dc66a528a 100644
--- a/tests/ui/parser/issues/issue-87812.stderr
+++ b/tests/ui/parser/issues/issue-87812.stderr
@@ -18,5 +18,5 @@ help: wrap this expression in parentheses
 LL |             break '_l ($f);
    |                       +  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-88770.stderr b/tests/ui/parser/issues/issue-88770.stderr
index 836f44953d4..60ef025fa8b 100644
--- a/tests/ui/parser/issues/issue-88770.stderr
+++ b/tests/ui/parser/issues/issue-88770.stderr
@@ -10,5 +10,5 @@ LL | fn m(){print!("",(c for&g
 LL | e
    |   ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-88818.stderr b/tests/ui/parser/issues/issue-88818.stderr
index 6e624c5a284..10e0161066d 100644
--- a/tests/ui/parser/issues/issue-88818.stderr
+++ b/tests/ui/parser/issues/issue-88818.stderr
@@ -14,5 +14,5 @@ LL - impl for S { }
 LL + impl S { }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-89388.stderr b/tests/ui/parser/issues/issue-89388.stderr
index 366d05c2d94..d4987234a49 100644
--- a/tests/ui/parser/issues/issue-89388.stderr
+++ b/tests/ui/parser/issues/issue-89388.stderr
@@ -9,5 +9,5 @@ help: types that don't start with an identifier need to be surrounded with angle
 LL |     let _ = option.map(<[_]>::to_vec);
    |                        +   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-89574.stderr b/tests/ui/parser/issues/issue-89574.stderr
index fb1312c782a..5f8f6f93969 100644
--- a/tests/ui/parser/issues/issue-89574.stderr
+++ b/tests/ui/parser/issues/issue-89574.stderr
@@ -4,5 +4,5 @@ error: missing type for `const` item
 LL |     const EMPTY_ARRAY = [];
    |                      ^ help: provide a type for the item: `: <type>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr b/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr
index a5ee2444520..51df17c7cc6 100644
--- a/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr
+++ b/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr
@@ -14,5 +14,5 @@ LL - #![deny(missing_docs)]
 LL + #[deny(missing_docs)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-91421.stderr b/tests/ui/parser/issues/issue-91421.stderr
index 2d9652051dd..99339a285ed 100644
--- a/tests/ui/parser/issues/issue-91421.stderr
+++ b/tests/ui/parser/issues/issue-91421.stderr
@@ -10,5 +10,5 @@ help: this binary operation is possibly unfinished
 LL |     let value = if true && {
    |                    ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-93867.stderr b/tests/ui/parser/issues/issue-93867.stderr
index ee0cb4efd74..c653c8dd4a4 100644
--- a/tests/ui/parser/issues/issue-93867.stderr
+++ b/tests/ui/parser/issues/issue-93867.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | pub fn entry<'a, K, V>() -> Entry<'a> K, V> {
    |                                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-98601-delimiter-error-1.stderr b/tests/ui/parser/issues/issue-98601-delimiter-error-1.stderr
index d568a4c583a..7dd059c6e3b 100644
--- a/tests/ui/parser/issues/issue-98601-delimiter-error-1.stderr
+++ b/tests/ui/parser/issues/issue-98601-delimiter-error-1.stderr
@@ -12,5 +12,5 @@ LL |     }
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-98601-delimiter-error-unexpected-close.stderr b/tests/ui/parser/issues/issue-98601-delimiter-error-unexpected-close.stderr
index 81dd39bb769..5e4b4dd3001 100644
--- a/tests/ui/parser/issues/issue-98601-delimiter-error-unexpected-close.stderr
+++ b/tests/ui/parser/issues/issue-98601-delimiter-error-unexpected-close.stderr
@@ -10,5 +10,5 @@ LL |
 LL | fn other(_: i32)) {}
    |                 ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-99625-enum-struct-mutually-exclusive.stderr b/tests/ui/parser/issues/issue-99625-enum-struct-mutually-exclusive.stderr
index edc640bf5ec..c503bc3ccfc 100644
--- a/tests/ui/parser/issues/issue-99625-enum-struct-mutually-exclusive.stderr
+++ b/tests/ui/parser/issues/issue-99625-enum-struct-mutually-exclusive.stderr
@@ -4,5 +4,5 @@ error: `enum` and `struct` are mutually exclusive
 LL | pub enum struct Range {
    |     ^^^^^^^^^^^ help: replace `enum struct` with: `enum`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-abstract.stderr b/tests/ui/parser/keyword-abstract.stderr
index b7d1ce7cd7c..156e098dab9 100644
--- a/tests/ui/parser/keyword-abstract.stderr
+++ b/tests/ui/parser/keyword-abstract.stderr
@@ -9,5 +9,5 @@ help: escape `abstract` to use it as an identifier
 LL |     let r#abstract = ();
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-as-as-identifier.stderr b/tests/ui/parser/keyword-as-as-identifier.stderr
index 3c5ad950db8..bc654cbc7c3 100644
--- a/tests/ui/parser/keyword-as-as-identifier.stderr
+++ b/tests/ui/parser/keyword-as-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `as` to use it as an identifier
 LL |     let r#as = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-break-as-identifier.stderr b/tests/ui/parser/keyword-break-as-identifier.stderr
index a4535eb40a1..63a9cbae519 100644
--- a/tests/ui/parser/keyword-break-as-identifier.stderr
+++ b/tests/ui/parser/keyword-break-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `break` to use it as an identifier
 LL |     let r#break = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-const-as-identifier.stderr b/tests/ui/parser/keyword-const-as-identifier.stderr
index 31922f150e5..61e454174dd 100644
--- a/tests/ui/parser/keyword-const-as-identifier.stderr
+++ b/tests/ui/parser/keyword-const-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `const` to use it as an identifier
 LL |     let r#const = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-continue-as-identifier.stderr b/tests/ui/parser/keyword-continue-as-identifier.stderr
index 81285633faa..2519000d28e 100644
--- a/tests/ui/parser/keyword-continue-as-identifier.stderr
+++ b/tests/ui/parser/keyword-continue-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `continue` to use it as an identifier
 LL |     let r#continue = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-else-as-identifier.stderr b/tests/ui/parser/keyword-else-as-identifier.stderr
index 2125fe84aed..e3eafa8fbbb 100644
--- a/tests/ui/parser/keyword-else-as-identifier.stderr
+++ b/tests/ui/parser/keyword-else-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `else` to use it as an identifier
 LL |     let r#else = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-enum-as-identifier.stderr b/tests/ui/parser/keyword-enum-as-identifier.stderr
index 92d092ccb65..280f8a2e1a1 100644
--- a/tests/ui/parser/keyword-enum-as-identifier.stderr
+++ b/tests/ui/parser/keyword-enum-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `enum` to use it as an identifier
 LL |     let r#enum = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-final.stderr b/tests/ui/parser/keyword-final.stderr
index f1f9f2e2c90..74866c9e7f9 100644
--- a/tests/ui/parser/keyword-final.stderr
+++ b/tests/ui/parser/keyword-final.stderr
@@ -9,5 +9,5 @@ help: escape `final` to use it as an identifier
 LL |     let r#final = ();
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-fn-as-identifier.stderr b/tests/ui/parser/keyword-fn-as-identifier.stderr
index 645efbcae71..32fff1a6189 100644
--- a/tests/ui/parser/keyword-fn-as-identifier.stderr
+++ b/tests/ui/parser/keyword-fn-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `fn` to use it as an identifier
 LL |     let r#fn = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-for-as-identifier.stderr b/tests/ui/parser/keyword-for-as-identifier.stderr
index 26407cc4d3a..813bb3f3bd3 100644
--- a/tests/ui/parser/keyword-for-as-identifier.stderr
+++ b/tests/ui/parser/keyword-for-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `for` to use it as an identifier
 LL |     let r#for = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-if-as-identifier.stderr b/tests/ui/parser/keyword-if-as-identifier.stderr
index 26f9a15a7d0..245ff8977b3 100644
--- a/tests/ui/parser/keyword-if-as-identifier.stderr
+++ b/tests/ui/parser/keyword-if-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `if` to use it as an identifier
 LL |     let r#if = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-impl-as-identifier.stderr b/tests/ui/parser/keyword-impl-as-identifier.stderr
index 73a50bc38bc..fe840ba3d22 100644
--- a/tests/ui/parser/keyword-impl-as-identifier.stderr
+++ b/tests/ui/parser/keyword-impl-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `impl` to use it as an identifier
 LL |     let r#impl = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-in-as-identifier.stderr b/tests/ui/parser/keyword-in-as-identifier.stderr
index 98332b723f2..12fc0479f70 100644
--- a/tests/ui/parser/keyword-in-as-identifier.stderr
+++ b/tests/ui/parser/keyword-in-as-identifier.stderr
@@ -4,5 +4,5 @@ error: expected pattern, found keyword `in`
 LL |     let in = "foo";
    |         ^^ expected pattern
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-let-as-identifier.stderr b/tests/ui/parser/keyword-let-as-identifier.stderr
index 86faaed382f..69f570aa838 100644
--- a/tests/ui/parser/keyword-let-as-identifier.stderr
+++ b/tests/ui/parser/keyword-let-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `let` to use it as an identifier
 LL |     let r#let = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-loop-as-identifier.stderr b/tests/ui/parser/keyword-loop-as-identifier.stderr
index 304ad61ccaf..ff14af0c7d7 100644
--- a/tests/ui/parser/keyword-loop-as-identifier.stderr
+++ b/tests/ui/parser/keyword-loop-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `loop` to use it as an identifier
 LL |     let r#loop = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-match-as-identifier.stderr b/tests/ui/parser/keyword-match-as-identifier.stderr
index 25ac397fb7e..3811ef058b9 100644
--- a/tests/ui/parser/keyword-match-as-identifier.stderr
+++ b/tests/ui/parser/keyword-match-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `match` to use it as an identifier
 LL |     let r#match = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-mod-as-identifier.stderr b/tests/ui/parser/keyword-mod-as-identifier.stderr
index d5688e871b2..c60d6f1295b 100644
--- a/tests/ui/parser/keyword-mod-as-identifier.stderr
+++ b/tests/ui/parser/keyword-mod-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `mod` to use it as an identifier
 LL |     let r#mod = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-move-as-identifier.stderr b/tests/ui/parser/keyword-move-as-identifier.stderr
index 75653cffc13..91cded8e9fb 100644
--- a/tests/ui/parser/keyword-move-as-identifier.stderr
+++ b/tests/ui/parser/keyword-move-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `move` to use it as an identifier
 LL |     let r#move = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-mut-as-identifier.stderr b/tests/ui/parser/keyword-mut-as-identifier.stderr
index 040960835d8..335b31a20e1 100644
--- a/tests/ui/parser/keyword-mut-as-identifier.stderr
+++ b/tests/ui/parser/keyword-mut-as-identifier.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `=`
 LL |     let mut = "foo";
    |             ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-override.stderr b/tests/ui/parser/keyword-override.stderr
index cdb5736866d..108a621a24e 100644
--- a/tests/ui/parser/keyword-override.stderr
+++ b/tests/ui/parser/keyword-override.stderr
@@ -9,5 +9,5 @@ help: escape `override` to use it as an identifier
 LL |     let r#override = ();
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-pub-as-identifier.stderr b/tests/ui/parser/keyword-pub-as-identifier.stderr
index 8d513507c81..ec62fd4cfde 100644
--- a/tests/ui/parser/keyword-pub-as-identifier.stderr
+++ b/tests/ui/parser/keyword-pub-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `pub` to use it as an identifier
 LL |     let r#pub = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-ref-as-identifier.stderr b/tests/ui/parser/keyword-ref-as-identifier.stderr
index 618043d89ff..54c258d7ad9 100644
--- a/tests/ui/parser/keyword-ref-as-identifier.stderr
+++ b/tests/ui/parser/keyword-ref-as-identifier.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `=`
 LL |     let ref = "foo";
    |             ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-return-as-identifier.stderr b/tests/ui/parser/keyword-return-as-identifier.stderr
index eeb8e468ba6..9e41d0ccbf6 100644
--- a/tests/ui/parser/keyword-return-as-identifier.stderr
+++ b/tests/ui/parser/keyword-return-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `return` to use it as an identifier
 LL |     let r#return = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-static-as-identifier.stderr b/tests/ui/parser/keyword-static-as-identifier.stderr
index a3213e2f297..76fb3afd681 100644
--- a/tests/ui/parser/keyword-static-as-identifier.stderr
+++ b/tests/ui/parser/keyword-static-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `static` to use it as an identifier
 LL |     let r#static = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-struct-as-identifier.stderr b/tests/ui/parser/keyword-struct-as-identifier.stderr
index b73361a5585..89eb644e106 100644
--- a/tests/ui/parser/keyword-struct-as-identifier.stderr
+++ b/tests/ui/parser/keyword-struct-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `struct` to use it as an identifier
 LL |     let r#struct = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-trait-as-identifier.stderr b/tests/ui/parser/keyword-trait-as-identifier.stderr
index 56ef5f60690..3f19f6f3c81 100644
--- a/tests/ui/parser/keyword-trait-as-identifier.stderr
+++ b/tests/ui/parser/keyword-trait-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `trait` to use it as an identifier
 LL |     let r#trait = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-try-as-identifier-edition2018.stderr b/tests/ui/parser/keyword-try-as-identifier-edition2018.stderr
index 94a106d47d7..ded65230262 100644
--- a/tests/ui/parser/keyword-try-as-identifier-edition2018.stderr
+++ b/tests/ui/parser/keyword-try-as-identifier-edition2018.stderr
@@ -9,5 +9,5 @@ help: escape `try` to use it as an identifier
 LL |     let r#try = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-type-as-identifier.stderr b/tests/ui/parser/keyword-type-as-identifier.stderr
index 624c1006b12..5e6c6d9e1d5 100644
--- a/tests/ui/parser/keyword-type-as-identifier.stderr
+++ b/tests/ui/parser/keyword-type-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `type` to use it as an identifier
 LL |     let r#type = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-typeof.stderr b/tests/ui/parser/keyword-typeof.stderr
index 4c5324505e9..c671ba94c4e 100644
--- a/tests/ui/parser/keyword-typeof.stderr
+++ b/tests/ui/parser/keyword-typeof.stderr
@@ -9,5 +9,5 @@ help: escape `typeof` to use it as an identifier
 LL |     let r#typeof = ();
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-unsafe-as-identifier.stderr b/tests/ui/parser/keyword-unsafe-as-identifier.stderr
index b552c9cd386..25a8001c681 100644
--- a/tests/ui/parser/keyword-unsafe-as-identifier.stderr
+++ b/tests/ui/parser/keyword-unsafe-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `unsafe` to use it as an identifier
 LL |     let r#unsafe = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-use-as-identifier.stderr b/tests/ui/parser/keyword-use-as-identifier.stderr
index 630798659a8..26bf2b4f64b 100644
--- a/tests/ui/parser/keyword-use-as-identifier.stderr
+++ b/tests/ui/parser/keyword-use-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `use` to use it as an identifier
 LL |     let r#use = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-where-as-identifier.stderr b/tests/ui/parser/keyword-where-as-identifier.stderr
index 9e72f794042..5243f04888f 100644
--- a/tests/ui/parser/keyword-where-as-identifier.stderr
+++ b/tests/ui/parser/keyword-where-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `where` to use it as an identifier
 LL |     let r#where = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword-while-as-identifier.stderr b/tests/ui/parser/keyword-while-as-identifier.stderr
index 2bb62105d17..ea396c61384 100644
--- a/tests/ui/parser/keyword-while-as-identifier.stderr
+++ b/tests/ui/parser/keyword-while-as-identifier.stderr
@@ -9,5 +9,5 @@ help: escape `while` to use it as an identifier
 LL |     let r#while = "foo";
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/keyword.stderr b/tests/ui/parser/keyword.stderr
index ee7d72b3996..54539519ec1 100644
--- a/tests/ui/parser/keyword.stderr
+++ b/tests/ui/parser/keyword.stderr
@@ -9,5 +9,5 @@ help: escape `break` to use it as an identifier
 LL | pub mod r#break {
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/lifetime-semicolon.stderr b/tests/ui/parser/lifetime-semicolon.stderr
index ee486c2366c..4f8e2835e08 100644
--- a/tests/ui/parser/lifetime-semicolon.stderr
+++ b/tests/ui/parser/lifetime-semicolon.stderr
@@ -9,5 +9,5 @@ help: use a comma to separate type parameters
 LL | fn foo<'a, 'b>(_x: &mut Foo<'a, 'b>) {}
    |                               ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/lit-err-in-macro.stderr b/tests/ui/parser/lit-err-in-macro.stderr
index a61fb5c85d4..12e6d519060 100644
--- a/tests/ui/parser/lit-err-in-macro.stderr
+++ b/tests/ui/parser/lit-err-in-macro.stderr
@@ -4,5 +4,5 @@ error: suffixes on string literals are invalid
 LL | f!("Foo"__);
    |    ^^^^^^^ invalid suffix `__`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro-bad-delimiter-ident.stderr b/tests/ui/parser/macro-bad-delimiter-ident.stderr
index f2365fed273..06f72cdecf2 100644
--- a/tests/ui/parser/macro-bad-delimiter-ident.stderr
+++ b/tests/ui/parser/macro-bad-delimiter-ident.stderr
@@ -4,5 +4,5 @@ error: expected one of `(`, `[`, or `{`, found `bar`
 LL |     foo! bar <
    |          ^^^ expected one of `(`, `[`, or `{`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro-keyword.stderr b/tests/ui/parser/macro-keyword.stderr
index d794671f8ab..bfe89e320e0 100644
--- a/tests/ui/parser/macro-keyword.stderr
+++ b/tests/ui/parser/macro-keyword.stderr
@@ -9,5 +9,5 @@ help: escape `macro` to use it as an identifier
 LL | fn r#macro() {
    |    ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro-mismatched-delim-brace-paren.stderr b/tests/ui/parser/macro-mismatched-delim-brace-paren.stderr
index 077d3180048..f9a3072229f 100644
--- a/tests/ui/parser/macro-mismatched-delim-brace-paren.stderr
+++ b/tests/ui/parser/macro-mismatched-delim-brace-paren.stderr
@@ -7,5 +7,5 @@ LL |         bar, "baz", 1, 2.0
 LL |     )
    |     ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro/bad-macro-argument.stderr b/tests/ui/parser/macro/bad-macro-argument.stderr
index 3cd8accb662..ba6499d712e 100644
--- a/tests/ui/parser/macro/bad-macro-argument.stderr
+++ b/tests/ui/parser/macro/bad-macro-argument.stderr
@@ -4,5 +4,5 @@ error: expected expression, found end of macro arguments
 LL |     println!("Hello, {}", message/);
    |                                   ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro/issue-37113.stderr b/tests/ui/parser/macro/issue-37113.stderr
index da9e743a0b4..1f2fe23106a 100644
--- a/tests/ui/parser/macro/issue-37113.stderr
+++ b/tests/ui/parser/macro/issue-37113.stderr
@@ -12,5 +12,5 @@ LL |     test_macro!(String,);
    = help: enum variants can be `Variant`, `Variant = <integer>`, `Variant(Type, ..., TypeN)` or `Variant { fields: Types }`
    = note: this error originates in the macro `test_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro/issue-37234.stderr b/tests/ui/parser/macro/issue-37234.stderr
index d7919620449..cd91ea44122 100644
--- a/tests/ui/parser/macro/issue-37234.stderr
+++ b/tests/ui/parser/macro/issue-37234.stderr
@@ -9,5 +9,5 @@ LL |     failed!();
    |
    = note: this error originates in the macro `failed` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro/macro-doc-comments-1.stderr b/tests/ui/parser/macro/macro-doc-comments-1.stderr
index eaeb62d2cfd..9d2d1bc0072 100644
--- a/tests/ui/parser/macro/macro-doc-comments-1.stderr
+++ b/tests/ui/parser/macro/macro-doc-comments-1.stderr
@@ -16,5 +16,5 @@ note: while trying to match `[`
 LL |     (#[$outer:meta]) => ()
    |       ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro/macro-doc-comments-2.stderr b/tests/ui/parser/macro/macro-doc-comments-2.stderr
index 1dcd95f6fad..22efd995b46 100644
--- a/tests/ui/parser/macro/macro-doc-comments-2.stderr
+++ b/tests/ui/parser/macro/macro-doc-comments-2.stderr
@@ -16,5 +16,5 @@ note: while trying to match `!`
 LL |     (#![$inner:meta]) => ()
    |       ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/macro/macro-expand-to-match-arm.stderr b/tests/ui/parser/macro/macro-expand-to-match-arm.stderr
index 1a5f4696858..1b34d2d12b2 100644
--- a/tests/ui/parser/macro/macro-expand-to-match-arm.stderr
+++ b/tests/ui/parser/macro/macro-expand-to-match-arm.stderr
@@ -6,5 +6,5 @@ LL |         arm!(None => {}),
    |
    = note: macros cannot expand to match arms
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/match-arrows-block-then-binop.stderr b/tests/ui/parser/match-arrows-block-then-binop.stderr
index cb361a3db53..7ef5228a8ed 100644
--- a/tests/ui/parser/match-arrows-block-then-binop.stderr
+++ b/tests/ui/parser/match-arrows-block-then-binop.stderr
@@ -11,5 +11,5 @@ LL |         0
 LL ~       }) + 5
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/match-refactor-to-expr.stderr b/tests/ui/parser/match-refactor-to-expr.stderr
index 851bef8f2c7..72dfcd7dd7d 100644
--- a/tests/ui/parser/match-refactor-to-expr.stderr
+++ b/tests/ui/parser/match-refactor-to-expr.stderr
@@ -12,5 +12,5 @@ LL |
 LL |         ;
    |         ^ unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/mbe_missing_right_paren.stderr b/tests/ui/parser/mbe_missing_right_paren.stderr
index d2af94683ef..d45a2e3ab52 100644
--- a/tests/ui/parser/mbe_missing_right_paren.stderr
+++ b/tests/ui/parser/mbe_missing_right_paren.stderr
@@ -6,5 +6,5 @@ LL | macro_rules! abc(ؼ
    |                 |
    |                 unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/method-call-on-struct-literal-in-if-condition.stderr b/tests/ui/parser/method-call-on-struct-literal-in-if-condition.stderr
index dedbad90945..f7822ba1124 100644
--- a/tests/ui/parser/method-call-on-struct-literal-in-if-condition.stderr
+++ b/tests/ui/parser/method-call-on-struct-literal-in-if-condition.stderr
@@ -9,5 +9,5 @@ help: you might need to surround the struct literal with parentheses
 LL |     if (Example { a: one(), }).is_pos() {
    |        +                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/mismatched-braces/missing-close-brace-in-impl-trait.stderr b/tests/ui/parser/mismatched-braces/missing-close-brace-in-impl-trait.stderr
index d91a7f0542d..97aac661d46 100644
--- a/tests/ui/parser/mismatched-braces/missing-close-brace-in-impl-trait.stderr
+++ b/tests/ui/parser/mismatched-braces/missing-close-brace-in-impl-trait.stderr
@@ -7,5 +7,5 @@ LL | impl T for () {
 LL |
    |                                                    ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr b/tests/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr
index d01d9ed60e4..f70dac443e5 100644
--- a/tests/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr
+++ b/tests/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr
@@ -7,5 +7,5 @@ LL | pub(crate) struct Bar<T> {
 LL | fn main() {}
    |                                                                 ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/mismatched-braces/missing-close-brace-in-trait.stderr b/tests/ui/parser/mismatched-braces/missing-close-brace-in-trait.stderr
index 7418dd64c9e..a565ad49b22 100644
--- a/tests/ui/parser/mismatched-braces/missing-close-brace-in-trait.stderr
+++ b/tests/ui/parser/mismatched-braces/missing-close-brace-in-trait.stderr
@@ -7,5 +7,5 @@ LL | trait T {
 LL | fn main() {}
    |                                                                 ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/mismatched-delim-brace-empty-block.stderr b/tests/ui/parser/mismatched-delim-brace-empty-block.stderr
index 165eb8ae932..180798788df 100644
--- a/tests/ui/parser/mismatched-delim-brace-empty-block.stderr
+++ b/tests/ui/parser/mismatched-delim-brace-empty-block.stderr
@@ -10,5 +10,5 @@ LL |     let _ = ();
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/missing-closing-angle-bracket-struct-field-ty.stderr b/tests/ui/parser/missing-closing-angle-bracket-struct-field-ty.stderr
index 6d8b0c3fccd..29a5dbb737a 100644
--- a/tests/ui/parser/missing-closing-angle-bracket-struct-field-ty.stderr
+++ b/tests/ui/parser/missing-closing-angle-bracket-struct-field-ty.stderr
@@ -14,5 +14,5 @@ help: you might have meant to end the type parameters here
 LL |     b: Arc<Mutex<usize>>,
    |                        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/missing-expression-in-for-loop.stderr b/tests/ui/parser/missing-expression-in-for-loop.stderr
index 74a7c4224fa..74acfc829a4 100644
--- a/tests/ui/parser/missing-expression-in-for-loop.stderr
+++ b/tests/ui/parser/missing-expression-in-for-loop.stderr
@@ -9,5 +9,5 @@ help: try adding an expression to the `for` loop
 LL |     for i in /* expression */ {
    |              ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/missing-semicolon.stderr b/tests/ui/parser/missing-semicolon.stderr
index e0d5e84ec31..4108cced366 100644
--- a/tests/ui/parser/missing-semicolon.stderr
+++ b/tests/ui/parser/missing-semicolon.stderr
@@ -9,5 +9,5 @@ LL | fn main() { m!(0, 0; 0, 0); }
    |
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/missing_right_paren.rs b/tests/ui/parser/missing_right_paren.rs
index e240f8c6739..cc6d30c9cac 100644
--- a/tests/ui/parser/missing_right_paren.rs
+++ b/tests/ui/parser/missing_right_paren.rs
@@ -1,4 +1,4 @@
 // ignore-tidy-trailing-newlines
 // error-pattern: this file contains an unclosed delimiter
-// error-pattern: aborting due to previous error
+// error-pattern: aborting due to 1 previous error
 fn main((ؼ
\ No newline at end of file
diff --git a/tests/ui/parser/missing_right_paren.stderr b/tests/ui/parser/missing_right_paren.stderr
index 994ce4d8541..4815f04fbce 100644
--- a/tests/ui/parser/missing_right_paren.stderr
+++ b/tests/ui/parser/missing_right_paren.stderr
@@ -7,5 +7,5 @@ LL | fn main((ؼ
    |        |unclosed delimiter
    |        unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/misspelled-macro-rules.stderr b/tests/ui/parser/misspelled-macro-rules.stderr
index 56df7123819..fc718d8556d 100644
--- a/tests/ui/parser/misspelled-macro-rules.stderr
+++ b/tests/ui/parser/misspelled-macro-rules.stderr
@@ -6,5 +6,5 @@ LL | marco_rules! thing {
    | |
    | help: perhaps you meant to define a macro: `macro_rules`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/mod_file_with_path_attr.stderr b/tests/ui/parser/mod_file_with_path_attr.stderr
index cd1add73d58..9ccb775daab 100644
--- a/tests/ui/parser/mod_file_with_path_attr.stderr
+++ b/tests/ui/parser/mod_file_with_path_attr.stderr
@@ -4,5 +4,5 @@ error: couldn't read $DIR/not_a_real_file.rs: $FILE_NOT_FOUND_MSG (os error 2)
 LL | mod m;
    | ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/multiline-comment-line-tracking.stderr b/tests/ui/parser/multiline-comment-line-tracking.stderr
index cac0c801a59..450a91207b7 100644
--- a/tests/ui/parser/multiline-comment-line-tracking.stderr
+++ b/tests/ui/parser/multiline-comment-line-tracking.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `%`
 LL |   %;
    |   ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/multitrait.stderr b/tests/ui/parser/multitrait.stderr
index 5a8bb2f7a45..6100f64e3ec 100644
--- a/tests/ui/parser/multitrait.stderr
+++ b/tests/ui/parser/multitrait.stderr
@@ -4,5 +4,5 @@ error: expected one of `!`, `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `
 LL | impl Cmp, ToString for S {
    |         ^ expected one of 8 possible tokens
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/nested-bad-turbofish.stderr b/tests/ui/parser/nested-bad-turbofish.stderr
index d82fa80e594..a23c23c41df 100644
--- a/tests/ui/parser/nested-bad-turbofish.stderr
+++ b/tests/ui/parser/nested-bad-turbofish.stderr
@@ -7,5 +7,5 @@ LL |     foo<<S as T>::V>();
    = help: use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments
    = help: or use `(...)` if you meant to specify fn arguments
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/nested-missing-closing-angle-bracket.stderr b/tests/ui/parser/nested-missing-closing-angle-bracket.stderr
index b85bc02568c..8d69125f8e9 100644
--- a/tests/ui/parser/nested-missing-closing-angle-bracket.stderr
+++ b/tests/ui/parser/nested-missing-closing-angle-bracket.stderr
@@ -4,5 +4,5 @@ error: expected one of `,` or `>`, found `;`
 LL |   let v : Vec::<Vec<(u32,_,_)> = vec![vec![]];
    |       - while parsing the type for `v`       ^ expected one of `,` or `>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/new-unicode-escapes-1.stderr b/tests/ui/parser/new-unicode-escapes-1.stderr
index d133e46b4b0..491915c89cc 100644
--- a/tests/ui/parser/new-unicode-escapes-1.stderr
+++ b/tests/ui/parser/new-unicode-escapes-1.stderr
@@ -9,5 +9,5 @@ help: terminate the unicode escape
 LL |     let s = "\u{2603}";
    |                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/new-unicode-escapes-2.stderr b/tests/ui/parser/new-unicode-escapes-2.stderr
index 2f3f8c0f9da..e0bdf533d3e 100644
--- a/tests/ui/parser/new-unicode-escapes-2.stderr
+++ b/tests/ui/parser/new-unicode-escapes-2.stderr
@@ -4,5 +4,5 @@ error: overlong unicode escape
 LL |     let s = "\u{260311111111}";
    |              ^^^^^^^^^^^^^^^^ must have at most 6 hex digits
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/new-unicode-escapes-4.stderr b/tests/ui/parser/new-unicode-escapes-4.stderr
index 514591af17e..d62afee7f00 100644
--- a/tests/ui/parser/new-unicode-escapes-4.stderr
+++ b/tests/ui/parser/new-unicode-escapes-4.stderr
@@ -4,5 +4,5 @@ error: invalid character in unicode escape: `l`
 LL |     let s = "\u{lol}";
    |                 ^ invalid character in unicode escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/obsolete-syntax-impl-for-dotdot.stderr b/tests/ui/parser/obsolete-syntax-impl-for-dotdot.stderr
index b7108ced0d7..d5f404bed31 100644
--- a/tests/ui/parser/obsolete-syntax-impl-for-dotdot.stderr
+++ b/tests/ui/parser/obsolete-syntax-impl-for-dotdot.stderr
@@ -6,5 +6,5 @@ LL | impl Trait2 for .. {}
    |
    = help: use `auto trait Trait {}` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/omitted-arg-in-item-fn.stderr b/tests/ui/parser/omitted-arg-in-item-fn.stderr
index ce2eab051ad..6f2a9f64c94 100644
--- a/tests/ui/parser/omitted-arg-in-item-fn.stderr
+++ b/tests/ui/parser/omitted-arg-in-item-fn.stderr
@@ -18,5 +18,5 @@ help: if this is a type, explicitly ignore the parameter name
 LL | fn foo(_: x) {
    |        ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/paamayim-nekudotayim.stderr b/tests/ui/parser/paamayim-nekudotayim.stderr
index 6ceba07f469..7d40cd63ffb 100644
--- a/tests/ui/parser/paamayim-nekudotayim.stderr
+++ b/tests/ui/parser/paamayim-nekudotayim.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `;`
 LL |     ::;
    |       ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/parser-recovery-1.stderr b/tests/ui/parser/parser-recovery-1.stderr
index 7045b6f5b78..8162db3d8e5 100644
--- a/tests/ui/parser/parser-recovery-1.stderr
+++ b/tests/ui/parser/parser-recovery-1.stderr
@@ -12,5 +12,5 @@ LL | }
 LL | }
    |                                                      ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/parser-recovery-2.stderr b/tests/ui/parser/parser-recovery-2.stderr
index f396e5fde5b..d3d6c9b0810 100644
--- a/tests/ui/parser/parser-recovery-2.stderr
+++ b/tests/ui/parser/parser-recovery-2.stderr
@@ -7,5 +7,5 @@ LL |         let x = foo();
 LL |     )
    |     ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-lt-bracket-1.stderr b/tests/ui/parser/pat-lt-bracket-1.stderr
index e8ccbad668a..14e679bbee0 100644
--- a/tests/ui/parser/pat-lt-bracket-1.stderr
+++ b/tests/ui/parser/pat-lt-bracket-1.stderr
@@ -4,5 +4,5 @@ error: expected one of `=>`, `@`, `if`, or `|`, found `<`
 LL |     x < 7 => (),
    |       ^ expected one of `=>`, `@`, `if`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-lt-bracket-2.stderr b/tests/ui/parser/pat-lt-bracket-2.stderr
index c78f96e1add..5fe97b2ef4c 100644
--- a/tests/ui/parser/pat-lt-bracket-2.stderr
+++ b/tests/ui/parser/pat-lt-bracket-2.stderr
@@ -14,5 +14,5 @@ help: if this is a type, explicitly ignore the parameter name
 LL | fn a(_: B<) {}
    |      ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-lt-bracket-3.stderr b/tests/ui/parser/pat-lt-bracket-3.stderr
index afdf1e9a557..cdb1b317735 100644
--- a/tests/ui/parser/pat-lt-bracket-3.stderr
+++ b/tests/ui/parser/pat-lt-bracket-3.stderr
@@ -9,5 +9,5 @@ help: use `::<...>` instead of `<...>` to specify lifetime, type, or const argum
 LL |             Foo::<T>(x, y) => {
    |                ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-lt-bracket-4.stderr b/tests/ui/parser/pat-lt-bracket-4.stderr
index b71a5ad939e..92d16564ab4 100644
--- a/tests/ui/parser/pat-lt-bracket-4.stderr
+++ b/tests/ui/parser/pat-lt-bracket-4.stderr
@@ -9,5 +9,5 @@ help: use `::<...>` instead of `<...>` to specify lifetime, type, or const argum
 LL |         Foo::<T>::A(value) => value,
    |            ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-lt-bracket-5.stderr b/tests/ui/parser/pat-lt-bracket-5.stderr
index e23674bcec5..e556e6c0206 100644
--- a/tests/ui/parser/pat-lt-bracket-5.stderr
+++ b/tests/ui/parser/pat-lt-bracket-5.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `;`, `=`, `@`, or `|`, found `[`
 LL |     let v[0] = v[1];
    |          ^ expected one of `:`, `;`, `=`, `@`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-ranges-1.stderr b/tests/ui/parser/pat-ranges-1.stderr
index b64a3ce5c08..e4d4e145c06 100644
--- a/tests/ui/parser/pat-ranges-1.stderr
+++ b/tests/ui/parser/pat-ranges-1.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `;`, `=`, or `|`, found `..=`
 LL |     let macropus!() ..= 11 = 12;
    |                     ^^^ expected one of `:`, `;`, `=`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-ranges-2.stderr b/tests/ui/parser/pat-ranges-2.stderr
index 1a9e33bebe9..c27436a81c5 100644
--- a/tests/ui/parser/pat-ranges-2.stderr
+++ b/tests/ui/parser/pat-ranges-2.stderr
@@ -4,5 +4,5 @@ error: expected one of `::`, `:`, `;`, `=`, or `|`, found `!`
 LL |     let 10 ..= makropulos!() = 12;
    |                          ^ expected one of `::`, `:`, `;`, `=`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-ranges-3.stderr b/tests/ui/parser/pat-ranges-3.stderr
index c9787b789a8..611b35a6502 100644
--- a/tests/ui/parser/pat-ranges-3.stderr
+++ b/tests/ui/parser/pat-ranges-3.stderr
@@ -4,5 +4,5 @@ error: expected one of `:`, `;`, `=`, or `|`, found `+`
 LL |     let 10 ..= 10 + 3 = 12;
    |                   ^ expected one of `:`, `;`, `=`, or `|`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-ranges-4.stderr b/tests/ui/parser/pat-ranges-4.stderr
index 69084b5a414..c30160291d6 100644
--- a/tests/ui/parser/pat-ranges-4.stderr
+++ b/tests/ui/parser/pat-ranges-4.stderr
@@ -4,5 +4,5 @@ error: expected one of `...`, `..=`, `..`, `:`, `;`, `=`, or `|`, found `-`
 LL |     let 10 - 3 ..= 10 = 8;
    |            ^ expected one of 7 possible tokens
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-ref-enum.stderr b/tests/ui/parser/pat-ref-enum.stderr
index a3bce337264..ecda487d0c5 100644
--- a/tests/ui/parser/pat-ref-enum.stderr
+++ b/tests/ui/parser/pat-ref-enum.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found enum pattern
 LL |       ref Some(i) => {}
    |           ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-tuple-1.stderr b/tests/ui/parser/pat-tuple-1.stderr
index 391f2c428bf..579365730c3 100644
--- a/tests/ui/parser/pat-tuple-1.stderr
+++ b/tests/ui/parser/pat-tuple-1.stderr
@@ -4,5 +4,5 @@ error: expected pattern, found `,`
 LL |         (, ..) => {}
    |          ^ expected pattern
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pat-tuple-3.stderr b/tests/ui/parser/pat-tuple-3.stderr
index 9ac0611c5c9..7ce00462be2 100644
--- a/tests/ui/parser/pat-tuple-3.stderr
+++ b/tests/ui/parser/pat-tuple-3.stderr
@@ -6,5 +6,5 @@ LL |         (.., pat, ..) => {}
    |          |
    |          previously used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/pub-method-macro.stderr b/tests/ui/parser/pub-method-macro.stderr
index 7c7a909267a..35cbf423079 100644
--- a/tests/ui/parser/pub-method-macro.stderr
+++ b/tests/ui/parser/pub-method-macro.stderr
@@ -6,5 +6,5 @@ LL |         pub defn!(f);
    |
    = help: try adjusting the macro to put `pub` inside the invocation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/public-instead-of-pub-1.stderr b/tests/ui/parser/public-instead-of-pub-1.stderr
index 795a5bcf5df..3fbe8d0b164 100644
--- a/tests/ui/parser/public-instead-of-pub-1.stderr
+++ b/tests/ui/parser/public-instead-of-pub-1.stderr
@@ -9,5 +9,5 @@ help: write `pub` instead of `public` to make the item public
 LL | pub enum Test {
    | ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/public-instead-of-pub-2.stderr b/tests/ui/parser/public-instead-of-pub-2.stderr
index efe225656fd..09d564d7a39 100644
--- a/tests/ui/parser/public-instead-of-pub-2.stderr
+++ b/tests/ui/parser/public-instead-of-pub-2.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `::`, found keyword `let`
 LL | public let x = 1;
    |        ^^^ expected one of `!` or `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/public-instead-of-pub-3.stderr b/tests/ui/parser/public-instead-of-pub-3.stderr
index 72efae08dda..b9b924e670a 100644
--- a/tests/ui/parser/public-instead-of-pub-3.stderr
+++ b/tests/ui/parser/public-instead-of-pub-3.stderr
@@ -9,5 +9,5 @@ help: write `pub` instead of `public` to make the item public
 LL |     pub const X: i32 = 123;
    |     ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/public-instead-of-pub.stderr b/tests/ui/parser/public-instead-of-pub.stderr
index af875491e85..c98f8a9914e 100644
--- a/tests/ui/parser/public-instead-of-pub.stderr
+++ b/tests/ui/parser/public-instead-of-pub.stderr
@@ -9,5 +9,5 @@ help: write `pub` instead of `public` to make the item public
 LL | pub struct X;
    | ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/qualified-path-in-turbofish.stderr b/tests/ui/parser/qualified-path-in-turbofish.stderr
index 8857d2ef30c..6e5af8cc1f0 100644
--- a/tests/ui/parser/qualified-path-in-turbofish.stderr
+++ b/tests/ui/parser/qualified-path-in-turbofish.stderr
@@ -4,5 +4,5 @@ error: found single colon before projection in qualified path
 LL |     template::<<Impl as T>:Ty>();
    |                           ^ help: use double colon: `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/range-3.stderr b/tests/ui/parser/range-3.stderr
index 340167f1804..c8f26a3ba1b 100644
--- a/tests/ui/parser/range-3.stderr
+++ b/tests/ui/parser/range-3.stderr
@@ -4,5 +4,5 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `..`
 LL |     let r = 1..2..3;
    |                 ^^ expected one of `.`, `;`, `?`, `else`, or an operator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/range-4.stderr b/tests/ui/parser/range-4.stderr
index 720d489389b..a797fa319c4 100644
--- a/tests/ui/parser/range-4.stderr
+++ b/tests/ui/parser/range-4.stderr
@@ -4,5 +4,5 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `..`
 LL |     let r = ..1..2;
    |                ^^ expected one of `.`, `;`, `?`, `else`, or an operator
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/range-inclusive-extra-equals.stderr b/tests/ui/parser/range-inclusive-extra-equals.stderr
index d37b6be4fa1..83df719dd3c 100644
--- a/tests/ui/parser/range-inclusive-extra-equals.stderr
+++ b/tests/ui/parser/range-inclusive-extra-equals.stderr
@@ -6,5 +6,5 @@ LL |     if let 1..==3 = 1 {}
    |
    = note: inclusive ranges end with a single equals sign (`..=`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/range_inclusive.stderr b/tests/ui/parser/range_inclusive.stderr
index 8a91782639f..0fd7f28db31 100644
--- a/tests/ui/parser/range_inclusive.stderr
+++ b/tests/ui/parser/range_inclusive.stderr
@@ -6,6 +6,6 @@ LL |     for _ in 1..= {}
    |
    = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0586`.
diff --git a/tests/ui/parser/raw/issue-70677-panic-on-unterminated-raw-str-at-eof.stderr b/tests/ui/parser/raw/issue-70677-panic-on-unterminated-raw-str-at-eof.stderr
index 3a7e2a4b14a..796b1324a5f 100644
--- a/tests/ui/parser/raw/issue-70677-panic-on-unterminated-raw-str-at-eof.stderr
+++ b/tests/ui/parser/raw/issue-70677-panic-on-unterminated-raw-str-at-eof.stderr
@@ -4,6 +4,6 @@ error[E0748]: unterminated raw string
 LL | r"
    | ^ unterminated raw string
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0748`.
diff --git a/tests/ui/parser/raw/raw-byte-string-eof.stderr b/tests/ui/parser/raw/raw-byte-string-eof.stderr
index a76668e8051..88fd53904c4 100644
--- a/tests/ui/parser/raw/raw-byte-string-eof.stderr
+++ b/tests/ui/parser/raw/raw-byte-string-eof.stderr
@@ -8,6 +8,6 @@ LL |     br##"a"#;
    |
    = note: this raw string should be terminated with `"##`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0748`.
diff --git a/tests/ui/parser/raw/raw-literal-self.stderr b/tests/ui/parser/raw/raw-literal-self.stderr
index 2a40dfe200c..f42c3e8e70c 100644
--- a/tests/ui/parser/raw/raw-literal-self.stderr
+++ b/tests/ui/parser/raw/raw-literal-self.stderr
@@ -4,5 +4,5 @@ error: `self` cannot be a raw identifier
 LL |     let r#self: ();
    |         ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/raw/raw-literal-underscore.stderr b/tests/ui/parser/raw/raw-literal-underscore.stderr
index d7a364d8579..2edba430d1d 100644
--- a/tests/ui/parser/raw/raw-literal-underscore.stderr
+++ b/tests/ui/parser/raw/raw-literal-underscore.stderr
@@ -4,5 +4,5 @@ error: `_` cannot be a raw identifier
 LL |     let r#_: ();
    |         ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/raw/raw-str-delim.stderr b/tests/ui/parser/raw/raw-str-delim.stderr
index 8a04f99a126..5edd18cb4a9 100644
--- a/tests/ui/parser/raw/raw-str-delim.stderr
+++ b/tests/ui/parser/raw/raw-str-delim.stderr
@@ -4,5 +4,5 @@ error: found invalid character; only `#` is allowed in raw string delimitation:
 LL |     r#~"#"~#
    |     ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/raw/raw-str-unterminated.stderr b/tests/ui/parser/raw/raw-str-unterminated.stderr
index 077f763f154..9d15a28173a 100644
--- a/tests/ui/parser/raw/raw-str-unterminated.stderr
+++ b/tests/ui/parser/raw/raw-str-unterminated.stderr
@@ -6,6 +6,6 @@ LL |     r#" string literal goes on
    |
    = note: this raw string should be terminated with `"#`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0748`.
diff --git a/tests/ui/parser/raw/raw-string-2.stderr b/tests/ui/parser/raw/raw-string-2.stderr
index 8bbac9d7bd0..90dd9775e62 100644
--- a/tests/ui/parser/raw/raw-string-2.stderr
+++ b/tests/ui/parser/raw/raw-string-2.stderr
@@ -6,6 +6,6 @@ LL |     let x = r###"here's a long string"# "# "##;
    |
    = note: this raw string should be terminated with `"###`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0748`.
diff --git a/tests/ui/parser/raw/raw-string.stderr b/tests/ui/parser/raw/raw-string.stderr
index b2b853a89e7..6654ef7a75a 100644
--- a/tests/ui/parser/raw/raw-string.stderr
+++ b/tests/ui/parser/raw/raw-string.stderr
@@ -8,6 +8,6 @@ LL |     let x = r##"lol"#;
    |
    = note: this raw string should be terminated with `"##`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0748`.
diff --git a/tests/ui/parser/raw/too-many-hash.stderr b/tests/ui/parser/raw/too-many-hash.stderr
index 29ec17842aa..1c46b5385cd 100644
--- a/tests/ui/parser/raw/too-many-hash.stderr
+++ b/tests/ui/parser/raw/too-many-hash.stderr
@@ -4,5 +4,5 @@ error: too many `#` symbols: raw strings may be delimited by up to 255 `#` symbo
 LL | ... = r################################################################################################################################################################################################################################################################"very raw"##############################################################################################################################################################################################################################################################...
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr b/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr
index 152f7f2fb06..cf50c026665 100644
--- a/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr
+++ b/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr
@@ -14,5 +14,5 @@ LL -     bar::<Item =   >();
 LL +     bar::<Item >();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recover/recover-assoc-lifetime-constraint.stderr b/tests/ui/parser/recover/recover-assoc-lifetime-constraint.stderr
index 79437533d7c..39a6682fcae 100644
--- a/tests/ui/parser/recover/recover-assoc-lifetime-constraint.stderr
+++ b/tests/ui/parser/recover/recover-assoc-lifetime-constraint.stderr
@@ -8,5 +8,5 @@ LL |     bar::<Item = 'a>();
    |
    = help: if you meant to specify a trait object, write `dyn Trait + 'lifetime`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recover/recover-field-extra-angle-brackets-in-struct-with-a-field.stderr b/tests/ui/parser/recover/recover-field-extra-angle-brackets-in-struct-with-a-field.stderr
index 17237c93097..2b56498c50d 100644
--- a/tests/ui/parser/recover/recover-field-extra-angle-brackets-in-struct-with-a-field.stderr
+++ b/tests/ui/parser/recover/recover-field-extra-angle-brackets-in-struct-with-a-field.stderr
@@ -7,5 +7,5 @@ LL | |
 LL | | }
    | |_ help: remove extra angle bracket
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recover/recover-field-extra-angle-brackets.stderr b/tests/ui/parser/recover/recover-field-extra-angle-brackets.stderr
index 318e55f6e99..628626926a7 100644
--- a/tests/ui/parser/recover/recover-field-extra-angle-brackets.stderr
+++ b/tests/ui/parser/recover/recover-field-extra-angle-brackets.stderr
@@ -4,5 +4,5 @@ error: unmatched angle bracket
 LL |     first: Vec<u8>>,
    |                   ^ help: remove extra angle bracket
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recover/recover-struct.stderr b/tests/ui/parser/recover/recover-struct.stderr
index 9f6fb06caa3..51a9e707756 100644
--- a/tests/ui/parser/recover/recover-struct.stderr
+++ b/tests/ui/parser/recover/recover-struct.stderr
@@ -8,5 +8,5 @@ LL |         Very
 LL |         Bad
    |         ^^^ unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recover/recover-tuple-pat.stderr b/tests/ui/parser/recover/recover-tuple-pat.stderr
index 93a6a66a630..e181f07201e 100644
--- a/tests/ui/parser/recover/recover-tuple-pat.stderr
+++ b/tests/ui/parser/recover/recover-tuple-pat.stderr
@@ -4,5 +4,5 @@ error: expected pattern, found `.`
 LL |         (1, .=., 4) => { let _: usize = ""; }
    |             ^ expected pattern
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/recovered-struct-variant.stderr b/tests/ui/parser/recovered-struct-variant.stderr
index 78c67866fb0..f0050394ba0 100644
--- a/tests/ui/parser/recovered-struct-variant.stderr
+++ b/tests/ui/parser/recovered-struct-variant.stderr
@@ -6,5 +6,5 @@ LL |     A { a, b: usize }
    |     |
    |     while parsing this struct
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/regions-out-of-scope-slice.stderr b/tests/ui/parser/regions-out-of-scope-slice.stderr
index bbc657ffd61..5d8f6af166b 100644
--- a/tests/ui/parser/regions-out-of-scope-slice.stderr
+++ b/tests/ui/parser/regions-out-of-scope-slice.stderr
@@ -7,5 +7,5 @@ LL |         x = &'blk [1,2,3];
    |              annotated with lifetime here
    |              help: remove the lifetime annotation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-closure-lifetime.stderr b/tests/ui/parser/removed-syntax-closure-lifetime.stderr
index e107c6b78b3..4c991d67ea7 100644
--- a/tests/ui/parser/removed-syntax-closure-lifetime.stderr
+++ b/tests/ui/parser/removed-syntax-closure-lifetime.stderr
@@ -9,5 +9,5 @@ help: you might have meant to end the type parameters here
 LL | type closure = Box<lt>/fn()>;
    |                      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-enum-newtype.stderr b/tests/ui/parser/removed-syntax-enum-newtype.stderr
index 8f7ca356798..5b917e93853 100644
--- a/tests/ui/parser/removed-syntax-enum-newtype.stderr
+++ b/tests/ui/parser/removed-syntax-enum-newtype.stderr
@@ -6,5 +6,5 @@ LL | enum e = isize;
    |      |
    |      while parsing this enum
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-field-let.stderr b/tests/ui/parser/removed-syntax-field-let.stderr
index 9bc18dabd6e..339d056e636 100644
--- a/tests/ui/parser/removed-syntax-field-let.stderr
+++ b/tests/ui/parser/removed-syntax-field-let.stderr
@@ -10,5 +10,5 @@ LL |     let foo: (),
    = note: the `let` keyword is not allowed in `struct` fields
    = note: see <https://doc.rust-lang.org/book/ch05-01-defining-structs.html> for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-field-semicolon.stderr b/tests/ui/parser/removed-syntax-field-semicolon.stderr
index 532d4fb2b61..522912a9e1c 100644
--- a/tests/ui/parser/removed-syntax-field-semicolon.stderr
+++ b/tests/ui/parser/removed-syntax-field-semicolon.stderr
@@ -6,5 +6,5 @@ LL | struct S {
 LL |     bar: ();
    |            ^ help: replace `;` with `,`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-fixed-vec.stderr b/tests/ui/parser/removed-syntax-fixed-vec.stderr
index a2b97544f9e..5bc9c2ccf00 100644
--- a/tests/ui/parser/removed-syntax-fixed-vec.stderr
+++ b/tests/ui/parser/removed-syntax-fixed-vec.stderr
@@ -4,5 +4,5 @@ error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `*`
 LL | type v = [isize * 3];
    |                 ^ expected one of 7 possible tokens
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-mode.stderr b/tests/ui/parser/removed-syntax-mode.stderr
index d0393b379f0..fd964c4b7f0 100644
--- a/tests/ui/parser/removed-syntax-mode.stderr
+++ b/tests/ui/parser/removed-syntax-mode.stderr
@@ -4,5 +4,5 @@ error: expected parameter name, found `+`
 LL | fn f(+x: isize) {}
    |      ^ expected parameter name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-mut-vec-expr.stderr b/tests/ui/parser/removed-syntax-mut-vec-expr.stderr
index 313420fb9a4..a1aa1ae49e3 100644
--- a/tests/ui/parser/removed-syntax-mut-vec-expr.stderr
+++ b/tests/ui/parser/removed-syntax-mut-vec-expr.stderr
@@ -4,5 +4,5 @@ error: expected expression, found keyword `mut`
 LL |     let v = [mut 1, 2, 3, 4];
    |              ^^^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-mut-vec-ty.stderr b/tests/ui/parser/removed-syntax-mut-vec-ty.stderr
index 02b518e2516..beaae7cddaa 100644
--- a/tests/ui/parser/removed-syntax-mut-vec-ty.stderr
+++ b/tests/ui/parser/removed-syntax-mut-vec-ty.stderr
@@ -4,5 +4,5 @@ error: expected type, found keyword `mut`
 LL | type v = [mut isize];
    |           ^^^ expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-ptr-lifetime.stderr b/tests/ui/parser/removed-syntax-ptr-lifetime.stderr
index 914de43e62d..5c74efffabf 100644
--- a/tests/ui/parser/removed-syntax-ptr-lifetime.stderr
+++ b/tests/ui/parser/removed-syntax-ptr-lifetime.stderr
@@ -4,5 +4,5 @@ error: expected one of `!`, `(`, `::`, `;`, `<`, or `where`, found `/`
 LL | type bptr = &lifetime/isize;
    |                      ^ expected one of `!`, `(`, `::`, `;`, `<`, or `where`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-record.stderr b/tests/ui/parser/removed-syntax-record.stderr
index 0a1655840b5..dbf09f1c75b 100644
--- a/tests/ui/parser/removed-syntax-record.stderr
+++ b/tests/ui/parser/removed-syntax-record.stderr
@@ -4,5 +4,5 @@ error: expected type, found `{`
 LL | type t = { f: () };
    |          ^ expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-uniq-mut-expr.stderr b/tests/ui/parser/removed-syntax-uniq-mut-expr.stderr
index 63d2fdb8cd4..7aaedad19d8 100644
--- a/tests/ui/parser/removed-syntax-uniq-mut-expr.stderr
+++ b/tests/ui/parser/removed-syntax-uniq-mut-expr.stderr
@@ -4,5 +4,5 @@ error: expected expression, found keyword `mut`
 LL |     let a_box = box mut 42;
    |                     ^^^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-uniq-mut-ty.stderr b/tests/ui/parser/removed-syntax-uniq-mut-ty.stderr
index 39db0be9fbb..5ae1f4f587e 100644
--- a/tests/ui/parser/removed-syntax-uniq-mut-ty.stderr
+++ b/tests/ui/parser/removed-syntax-uniq-mut-ty.stderr
@@ -4,5 +4,5 @@ error: expected one of `>`, a const expression, lifetime, or type, found keyword
 LL | type mut_box = Box<mut isize>;
    |                    ^^^ expected one of `>`, a const expression, lifetime, or type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/removed-syntax-with-1.stderr b/tests/ui/parser/removed-syntax-with-1.stderr
index c3f747b61b9..78042678a87 100644
--- a/tests/ui/parser/removed-syntax-with-1.stderr
+++ b/tests/ui/parser/removed-syntax-with-1.stderr
@@ -7,5 +7,5 @@ LL |     let b = S { foo: () with a, bar: () };
    |             |          help: try adding a comma: `,`
    |             while parsing this struct
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/self-in-function-arg.stderr b/tests/ui/parser/self-in-function-arg.stderr
index 47d8381b0b1..9ceec8d46d3 100644
--- a/tests/ui/parser/self-in-function-arg.stderr
+++ b/tests/ui/parser/self-in-function-arg.stderr
@@ -4,5 +4,5 @@ error: unexpected `self` parameter in function
 LL | fn foo(x:i32, self: i32) -> i32 { self }
    |               ^^^^ must be the first parameter of an associated function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/shebang/issue-71471-ignore-tidy.stderr b/tests/ui/parser/shebang/issue-71471-ignore-tidy.stderr
index 896a9dc83d8..41cd4fb93fa 100644
--- a/tests/ui/parser/shebang/issue-71471-ignore-tidy.stderr
+++ b/tests/ui/parser/shebang/issue-71471-ignore-tidy.stderr
@@ -4,5 +4,5 @@ error: expected `[`, found `B`
 LL | #!B
    |   ^ expected `[`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/shebang/shebang-doc-comment.stderr b/tests/ui/parser/shebang/shebang-doc-comment.stderr
index a36b2a2f72b..92fefded55a 100644
--- a/tests/ui/parser/shebang/shebang-doc-comment.stderr
+++ b/tests/ui/parser/shebang/shebang-doc-comment.stderr
@@ -6,5 +6,5 @@ LL | [allow(unused_variables)]
    |
    = note: for a full list of items that can appear in modules, see <https://doc.rust-lang.org/reference/items.html>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/shebang/shebang-must-start-file.stderr b/tests/ui/parser/shebang/shebang-must-start-file.stderr
index 50543e8bdb8..56991c96b7a 100644
--- a/tests/ui/parser/shebang/shebang-must-start-file.stderr
+++ b/tests/ui/parser/shebang/shebang-must-start-file.stderr
@@ -4,5 +4,5 @@ error: expected `[`, found `/`
 LL | #!/bin/bash
    |   ^ expected `[`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/similar-tokens.stderr b/tests/ui/parser/similar-tokens.stderr
index 90acfc052dd..7070232c142 100644
--- a/tests/ui/parser/similar-tokens.stderr
+++ b/tests/ui/parser/similar-tokens.stderr
@@ -7,5 +7,5 @@ LL | use x::{A. B};
    |          expected one of `,`, `::`, `as`, or `}`
    |          help: missing `,`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/struct-filed-with-attr.stderr b/tests/ui/parser/struct-filed-with-attr.stderr
index c2cd7e82ead..d850ed620de 100644
--- a/tests/ui/parser/struct-filed-with-attr.stderr
+++ b/tests/ui/parser/struct-filed-with-attr.stderr
@@ -4,5 +4,5 @@ error: expected `,`, or `}`, found `#`
 LL |     owo: bool
    |              ^ help: try adding a comma: `,`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/struct-literal-in-match-discriminant.stderr b/tests/ui/parser/struct-literal-in-match-discriminant.stderr
index 692b4d73503..5177f5f126e 100644
--- a/tests/ui/parser/struct-literal-in-match-discriminant.stderr
+++ b/tests/ui/parser/struct-literal-in-match-discriminant.stderr
@@ -14,5 +14,5 @@ LL |         x: 3
 LL ~     }) {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest-assoc-const.stderr b/tests/ui/parser/suggest-assoc-const.stderr
index 2ddfa07c5be..7ba1dbdff7e 100644
--- a/tests/ui/parser/suggest-assoc-const.stderr
+++ b/tests/ui/parser/suggest-assoc-const.stderr
@@ -4,5 +4,5 @@ error: non-item in item list
 LL |     let _X: i32;
    |     ^^^ help: consider using `const` instead of `let` for associated const: `const`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest-const-for-global-var.stderr b/tests/ui/parser/suggest-const-for-global-var.stderr
index 94e44ec7f6c..235e621d882 100644
--- a/tests/ui/parser/suggest-const-for-global-var.stderr
+++ b/tests/ui/parser/suggest-const-for-global-var.stderr
@@ -4,5 +4,5 @@ error: expected item, found keyword `let`
 LL | let X: i32 = 12;
    | ^^^ consider using `const` or `static` instead of `let` for global variables
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr b/tests/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr
index 396e0c130f1..c716d5908ea 100644
--- a/tests/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr
+++ b/tests/ui/parser/suggest-removing-semicolon-after-impl-trait-items.stderr
@@ -11,5 +11,5 @@ LL |     fn bar() {};
 LL | }
    | - item list ends here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest-semi-in-array.stderr b/tests/ui/parser/suggest-semi-in-array.stderr
index d7cd6efae41..25b0679957e 100644
--- a/tests/ui/parser/suggest-semi-in-array.stderr
+++ b/tests/ui/parser/suggest-semi-in-array.stderr
@@ -6,5 +6,5 @@ LL |     let v = [1
 LL |     2];
    |     ^ unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest-semicolon-before-array.stderr b/tests/ui/parser/suggest-semicolon-before-array.stderr
index 8a33321fbd5..f5573f5e4e3 100644
--- a/tests/ui/parser/suggest-semicolon-before-array.stderr
+++ b/tests/ui/parser/suggest-semicolon-before-array.stderr
@@ -9,5 +9,5 @@ help: consider adding `;` here
 LL |     foo();
    |          +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/enum.stderr b/tests/ui/parser/suggest_misplaced_generics/enum.stderr
index 5f5947627ee..7bef9d70988 100644
--- a/tests/ui/parser/suggest_misplaced_generics/enum.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/enum.stderr
@@ -10,5 +10,5 @@ LL - enum<T> Foo { Variant(T) }
 LL + enum Foo<T> { Variant(T) }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/existing_generics.stderr b/tests/ui/parser/suggest_misplaced_generics/existing_generics.stderr
index 89716e6f1ed..e887c088151 100644
--- a/tests/ui/parser/suggest_misplaced_generics/existing_generics.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/existing_generics.stderr
@@ -6,5 +6,5 @@ LL | fn<'a, B: 'a + std::ops::Add<Output = u32>> f<T>(_x: B) { }
    |
    = help: place the generic parameter name after the fn name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/fn-complex-generics.stderr b/tests/ui/parser/suggest_misplaced_generics/fn-complex-generics.stderr
index 061d0910a74..18e173a9db0 100644
--- a/tests/ui/parser/suggest_misplaced_generics/fn-complex-generics.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/fn-complex-generics.stderr
@@ -10,5 +10,5 @@ LL - fn<'a, B: 'a + std::ops::Add<Output = u32>> f(_x: B) { }
 LL + fn f<'a, B: 'a + std::ops::Add<Output = u32>>(_x: B) { }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/fn-invalid-generics.stderr b/tests/ui/parser/suggest_misplaced_generics/fn-invalid-generics.stderr
index 47e12016938..cde69083593 100644
--- a/tests/ui/parser/suggest_misplaced_generics/fn-invalid-generics.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/fn-invalid-generics.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `<`
 LL | fn<~>()> id(x: T) -> T { x }
    |   ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/fn-simple.stderr b/tests/ui/parser/suggest_misplaced_generics/fn-simple.stderr
index e749f1a0d00..e77df69eeb1 100644
--- a/tests/ui/parser/suggest_misplaced_generics/fn-simple.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/fn-simple.stderr
@@ -10,5 +10,5 @@ LL - fn<T> id(x: T) -> T { x }
 LL + fn id<T>(x: T) -> T { x }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/struct.stderr b/tests/ui/parser/suggest_misplaced_generics/struct.stderr
index 2b650907092..09e176adb4d 100644
--- a/tests/ui/parser/suggest_misplaced_generics/struct.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/struct.stderr
@@ -10,5 +10,5 @@ LL - struct<T> Foo { x: T }
 LL + struct Foo<T> { x: T }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/trait.stderr b/tests/ui/parser/suggest_misplaced_generics/trait.stderr
index ac86cfa4697..0d0b780d41f 100644
--- a/tests/ui/parser/suggest_misplaced_generics/trait.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/trait.stderr
@@ -10,5 +10,5 @@ LL - trait<T> Foo {
 LL + trait Foo<T> {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/suggest_misplaced_generics/type.stderr b/tests/ui/parser/suggest_misplaced_generics/type.stderr
index 22744f6cf37..3034535d556 100644
--- a/tests/ui/parser/suggest_misplaced_generics/type.stderr
+++ b/tests/ui/parser/suggest_misplaced_generics/type.stderr
@@ -10,5 +10,5 @@ LL - type<T> Foo = T;
 LL + type Foo<T> = T;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/trailing-carriage-return-in-string.stderr b/tests/ui/parser/trailing-carriage-return-in-string.stderr
index 8a44e02707c..fa2677921b3 100644
--- a/tests/ui/parser/trailing-carriage-return-in-string.stderr
+++ b/tests/ui/parser/trailing-carriage-return-in-string.stderr
@@ -6,5 +6,5 @@ LL |     let bad = "This is \
 a test";
    |
    = help: this is an isolated carriage return; consider checking your editor and version control settings
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/trailing-question-in-macro-type.stderr b/tests/ui/parser/trailing-question-in-macro-type.stderr
index c096ae04fbb..e3d33bf251d 100644
--- a/tests/ui/parser/trailing-question-in-macro-type.stderr
+++ b/tests/ui/parser/trailing-question-in-macro-type.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `o` in this scope
 LL |     fn_expr!{ o?.when(|&i| i > 0)?.when(|&i| i%2 == 0) };
    |               ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/parser/trait-bounds-not-on-impl.stderr b/tests/ui/parser/trait-bounds-not-on-impl.stderr
index 8d2d5e3d7dd..7f51bd97e5d 100644
--- a/tests/ui/parser/trait-bounds-not-on-impl.stderr
+++ b/tests/ui/parser/trait-bounds-not-on-impl.stderr
@@ -4,5 +4,5 @@ error: expected a trait, found type
 LL | impl Foo + Owned for Bar {}
    |      ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/trait-object-polytrait-priority.stderr b/tests/ui/parser/trait-object-polytrait-priority.stderr
index a6add6079ce..23ec1e9cf3d 100644
--- a/tests/ui/parser/trait-object-polytrait-priority.stderr
+++ b/tests/ui/parser/trait-object-polytrait-priority.stderr
@@ -4,6 +4,6 @@ error[E0178]: expected a path on the left-hand side of `+`, not `&for<'a> Trait<
 LL |     let _: &for<'a> Trait<'a> + 'static;
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try adding parentheses: `&(for<'a> Trait<'a> + 'static)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0178`.
diff --git a/tests/ui/parser/trait-pub-assoc-const.stderr b/tests/ui/parser/trait-pub-assoc-const.stderr
index c14a2f2eea5..436f6a3909c 100644
--- a/tests/ui/parser/trait-pub-assoc-const.stderr
+++ b/tests/ui/parser/trait-pub-assoc-const.stderr
@@ -6,6 +6,6 @@ LL |     pub const Foo: u32;
    |
    = note: trait items always share the visibility of their trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0449`.
diff --git a/tests/ui/parser/trait-pub-assoc-ty.stderr b/tests/ui/parser/trait-pub-assoc-ty.stderr
index 7f6e7350ca7..279e3a95354 100644
--- a/tests/ui/parser/trait-pub-assoc-ty.stderr
+++ b/tests/ui/parser/trait-pub-assoc-ty.stderr
@@ -6,6 +6,6 @@ LL |     pub type Foo;
    |
    = note: trait items always share the visibility of their trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0449`.
diff --git a/tests/ui/parser/trait-pub-method.stderr b/tests/ui/parser/trait-pub-method.stderr
index 2bf1d468a85..ee8b6f7cb62 100644
--- a/tests/ui/parser/trait-pub-method.stderr
+++ b/tests/ui/parser/trait-pub-method.stderr
@@ -6,6 +6,6 @@ LL |     pub fn foo();
    |
    = note: trait items always share the visibility of their trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0449`.
diff --git a/tests/ui/parser/unbalanced-doublequote.stderr b/tests/ui/parser/unbalanced-doublequote.stderr
index 94b300a7bd7..d40b982da7c 100644
--- a/tests/ui/parser/unbalanced-doublequote.stderr
+++ b/tests/ui/parser/unbalanced-doublequote.stderr
@@ -5,6 +5,6 @@ LL | /     "
 LL | | }
    | |__^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0765`.
diff --git a/tests/ui/parser/unclosed-braces.stderr b/tests/ui/parser/unclosed-braces.stderr
index cbc5f8de4c3..acd92ac7925 100644
--- a/tests/ui/parser/unclosed-braces.stderr
+++ b/tests/ui/parser/unclosed-braces.stderr
@@ -13,5 +13,5 @@ LL |     }
 LL |
    |                                                    ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unclosed-delimiter-in-dep.stderr b/tests/ui/parser/unclosed-delimiter-in-dep.stderr
index a46d020b967..1231decd9dd 100644
--- a/tests/ui/parser/unclosed-delimiter-in-dep.stderr
+++ b/tests/ui/parser/unclosed-delimiter-in-dep.stderr
@@ -9,5 +9,5 @@ LL |     }
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unclosed_delim_mod.stderr b/tests/ui/parser/unclosed_delim_mod.stderr
index a46d020b967..1231decd9dd 100644
--- a/tests/ui/parser/unclosed_delim_mod.stderr
+++ b/tests/ui/parser/unclosed_delim_mod.stderr
@@ -9,5 +9,5 @@ LL |     }
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unmatched-delimiter-at-end-of-file.stderr b/tests/ui/parser/unmatched-delimiter-at-end-of-file.stderr
index 430a13e6e07..c6960892b2b 100644
--- a/tests/ui/parser/unmatched-delimiter-at-end-of-file.stderr
+++ b/tests/ui/parser/unmatched-delimiter-at-end-of-file.stderr
@@ -4,5 +4,5 @@ error: this file contains an unclosed delimiter
 LL | fn foo() {
    |          - unclosed delimiter                                 ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unmatched-langle-2.stderr b/tests/ui/parser/unmatched-langle-2.stderr
index 773bb33d8d3..9881c6ba51b 100644
--- a/tests/ui/parser/unmatched-langle-2.stderr
+++ b/tests/ui/parser/unmatched-langle-2.stderr
@@ -4,5 +4,5 @@ error: expected `::`, found `(`
 LL |     foo::<Ty<<<i32>();
    |                    ^ expected `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unsafe-foreign-mod.stderr b/tests/ui/parser/unsafe-foreign-mod.stderr
index 4acf72c5dae..77f6e93be10 100644
--- a/tests/ui/parser/unsafe-foreign-mod.stderr
+++ b/tests/ui/parser/unsafe-foreign-mod.stderr
@@ -4,5 +4,5 @@ error: extern block cannot be declared unsafe
 LL | unsafe extern "C" {
    | ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unsized.stderr b/tests/ui/parser/unsized.stderr
index 3d4ed526b6a..1bb4aa97d8b 100644
--- a/tests/ui/parser/unsized.stderr
+++ b/tests/ui/parser/unsized.stderr
@@ -4,5 +4,5 @@ error: expected `where`, `{`, `(`, or `;` after struct name, found keyword `for`
 LL | struct S1 for type;
    |           ^^^ expected `where`, `{`, `(`, or `;` after struct name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/unsized2.stderr b/tests/ui/parser/unsized2.stderr
index 17e39b29200..10f4c8332a3 100644
--- a/tests/ui/parser/unsized2.stderr
+++ b/tests/ui/parser/unsized2.stderr
@@ -4,5 +4,5 @@ error: expected expression, found keyword `type`
 LL |     f<type>();
    |       ^^^^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/use-ends-with-mod-sep.stderr b/tests/ui/parser/use-ends-with-mod-sep.stderr
index bd0d881a06c..2f8e09c07e1 100644
--- a/tests/ui/parser/use-ends-with-mod-sep.stderr
+++ b/tests/ui/parser/use-ends-with-mod-sep.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `;`
 LL | use std::any::;
    |               ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/use-unclosed-brace.stderr b/tests/ui/parser/use-unclosed-brace.stderr
index ad5bb2de1b2..6e624cb9131 100644
--- a/tests/ui/parser/use-unclosed-brace.stderr
+++ b/tests/ui/parser/use-unclosed-brace.stderr
@@ -7,5 +7,5 @@ LL | use foo::{bar, baz;
 LL | fn main() {}
    |              ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/virtual-structs.stderr b/tests/ui/parser/virtual-structs.stderr
index 268fc105796..7b45e77ba9c 100644
--- a/tests/ui/parser/virtual-structs.stderr
+++ b/tests/ui/parser/virtual-structs.stderr
@@ -6,5 +6,5 @@ LL | virtual struct SuperStruct {
    |
    = note: for a full list of items that can appear in modules, see <https://doc.rust-lang.org/reference/items.html>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/where-clauses-no-bounds-or-predicates.stderr b/tests/ui/parser/where-clauses-no-bounds-or-predicates.stderr
index b80b0a40906..4bd0cc885c9 100644
--- a/tests/ui/parser/where-clauses-no-bounds-or-predicates.stderr
+++ b/tests/ui/parser/where-clauses-no-bounds-or-predicates.stderr
@@ -4,5 +4,5 @@ error: expected `:`, found `{`
 LL | fn foo<'a>() where 'a {}
    |                       ^ expected `:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/while-if-let-without-body.stderr b/tests/ui/parser/while-if-let-without-body.stderr
index 2dac45c115d..0bd68b7b9ae 100644
--- a/tests/ui/parser/while-if-let-without-body.stderr
+++ b/tests/ui/parser/while-if-let-without-body.stderr
@@ -14,5 +14,5 @@ LL | |     }
 LL |   }
    |   ^ expected `{`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr b/tests/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
index a481ca46833..4a6d36a4e0c 100644
--- a/tests/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
+++ b/tests/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
@@ -8,6 +8,6 @@ LL | fn f(a @ A(u): A) -> Box<u8> {
    |
    = note: partial move occurs because value has type `Box<u8>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr b/tests/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
index c440f4619f5..815a4ade995 100644
--- a/tests/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
+++ b/tests/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
@@ -12,5 +12,5 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |     let ref a @ ref b = U;
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr b/tests/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
index e0e623fa544..d0ffb59a6ec 100644
--- a/tests/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
+++ b/tests/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
@@ -12,6 +12,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |     let ref a @ NC(b, ref c @ NC(d, e)) = NC(C, NC(C, C));
    |         +++           +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/pattern/issue-114896.stderr b/tests/ui/pattern/issue-114896.stderr
index ffeb7bc1365..285c9109e1b 100644
--- a/tests/ui/pattern/issue-114896.stderr
+++ b/tests/ui/pattern/issue-114896.stderr
@@ -6,6 +6,6 @@ LL |         let &b = a;
 LL |         b.make_ascii_uppercase();
    |         ^ cannot borrow as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/pattern/issue-115599.stderr b/tests/ui/pattern/issue-115599.stderr
index e6cb6c1ddac..c1e85d0bb48 100644
--- a/tests/ui/pattern/issue-115599.stderr
+++ b/tests/ui/pattern/issue-115599.stderr
@@ -7,5 +7,5 @@ LL |     if let CONST_STRING = empty_str {}
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/issue-52240.stderr b/tests/ui/pattern/issue-52240.stderr
index 69b663b17d3..dcf3da45e53 100644
--- a/tests/ui/pattern/issue-52240.stderr
+++ b/tests/ui/pattern/issue-52240.stderr
@@ -4,6 +4,6 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     if let (Some(Foo::Bar(ref mut val)), _) = (&arr.get(0), 0) {
    |                           ^^^^^^^^^^^ cannot borrow as mutable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/pattern/issue-66270-pat-struct-parser-recovery.stderr b/tests/ui/pattern/issue-66270-pat-struct-parser-recovery.stderr
index f40642f300c..087ff513bb3 100644
--- a/tests/ui/pattern/issue-66270-pat-struct-parser-recovery.stderr
+++ b/tests/ui/pattern/issue-66270-pat-struct-parser-recovery.stderr
@@ -6,5 +6,5 @@ LL | struct Bug {
 LL |     incorrect_field: 0,
    |                      ^ expected type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/issue-72565.stderr b/tests/ui/pattern/issue-72565.stderr
index 0519720694d..b503a17fe84 100644
--- a/tests/ui/pattern/issue-72565.stderr
+++ b/tests/ui/pattern/issue-72565.stderr
@@ -4,5 +4,5 @@ error: `dyn PartialEq<u32>` cannot be used in patterns
 LL |         F => panic!(),
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/issue-80186-mut-binding-help-suggestion.stderr b/tests/ui/pattern/issue-80186-mut-binding-help-suggestion.stderr
index 75b6c163b2c..167016397d2 100644
--- a/tests/ui/pattern/issue-80186-mut-binding-help-suggestion.stderr
+++ b/tests/ui/pattern/issue-80186-mut-binding-help-suggestion.stderr
@@ -6,5 +6,5 @@ LL |     let mut &x = &0;
    |
    = note: `mut` may be followed by `variable` and `variable @ pattern`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/issue-94866.stderr b/tests/ui/pattern/issue-94866.stderr
index dee4b3f557c..8edb95f76f0 100644
--- a/tests/ui/pattern/issue-94866.stderr
+++ b/tests/ui/pattern/issue-94866.stderr
@@ -16,6 +16,6 @@ LL ~     Enum::A => m!(),
 LL +     Enum::B => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/issue-95878.stderr b/tests/ui/pattern/issue-95878.stderr
index e0eea06e0a3..e938c67f308 100644
--- a/tests/ui/pattern/issue-95878.stderr
+++ b/tests/ui/pattern/issue-95878.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found keyword `Self`
 LL |             ref Self => (),
    |                 ^^^^ expected identifier, found keyword
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr
index d3ab533e35e..85379d6605b 100644
--- a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr
+++ b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes-fixable.stderr
@@ -12,6 +12,6 @@ help: consider borrowing the pattern binding
 LL |     let (a, ref mut b) = &mut p;
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
index 65030b62250..494e5e2b2e8 100644
--- a/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
+++ b/tests/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
@@ -12,6 +12,6 @@ help: consider borrowing the pattern binding
 LL |     let (a, ref mut b) = &p;
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/pattern/pat-shadow-in-nested-binding.stderr b/tests/ui/pattern/pat-shadow-in-nested-binding.stderr
index 0c5824be95d..ad175710b09 100644
--- a/tests/ui/pattern/pat-shadow-in-nested-binding.stderr
+++ b/tests/ui/pattern/pat-shadow-in-nested-binding.stderr
@@ -7,6 +7,6 @@ LL | struct foo(usize);
 LL |     let (foo, _) = (2, 3);
    |          ^^^ cannot be named the same as a tuple struct
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0530`.
diff --git a/tests/ui/pattern/pat-struct-field-expr-has-type.stderr b/tests/ui/pattern/pat-struct-field-expr-has-type.stderr
index 02907529310..80bedfe7859 100644
--- a/tests/ui/pattern/pat-struct-field-expr-has-type.stderr
+++ b/tests/ui/pattern/pat-struct-field-expr-has-type.stderr
@@ -9,6 +9,6 @@ LL |         S { f: Ok(_) } => {}
    = note: expected type `u8`
               found enum `Result<_, _>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/pat-type-err-formal-param.stderr b/tests/ui/pattern/pat-type-err-formal-param.stderr
index 4f482c52a98..c100aa6070f 100644
--- a/tests/ui/pattern/pat-type-err-formal-param.stderr
+++ b/tests/ui/pattern/pat-type-err-formal-param.stderr
@@ -6,6 +6,6 @@ LL | fn foo(Tuple(_): String) {}
    |        |
    |        expected `String`, found `Tuple`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/pattern-ident-path-generics.stderr b/tests/ui/pattern/pattern-ident-path-generics.stderr
index 62283dfe9b6..942a4265075 100644
--- a/tests/ui/pattern/pattern-ident-path-generics.stderr
+++ b/tests/ui/pattern/pattern-ident-path-generics.stderr
@@ -9,6 +9,6 @@ LL |         None::<isize> => {}
    = note: expected enum `Option<&str>`
               found enum `Option<isize>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/pattern-tyvar-2.stderr b/tests/ui/pattern/pattern-tyvar-2.stderr
index 121817e7056..c6540e79558 100644
--- a/tests/ui/pattern/pattern-tyvar-2.stderr
+++ b/tests/ui/pattern/pattern-tyvar-2.stderr
@@ -6,6 +6,6 @@ LL | fn foo(t: Bar) -> isize { match t { Bar::T1(_, Some(x)) => { return x * 3;
    |                                                                     |
    |                                                                     Vec<isize>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/pattern/pattern-tyvar.stderr b/tests/ui/pattern/pattern-tyvar.stderr
index 4eb00254861..492b34cd292 100644
--- a/tests/ui/pattern/pattern-tyvar.stderr
+++ b/tests/ui/pattern/pattern-tyvar.stderr
@@ -9,6 +9,6 @@ LL |       Bar::T1(_, Some::<isize>(x)) => {
    = note: expected enum `Option<Vec<isize>>`
               found enum `Option<isize>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/slice-patterns-irrefutable.stderr b/tests/ui/pattern/slice-patterns-irrefutable.stderr
index e98ee28d686..9b46f8a8854 100644
--- a/tests/ui/pattern/slice-patterns-irrefutable.stderr
+++ b/tests/ui/pattern/slice-patterns-irrefutable.stderr
@@ -12,6 +12,6 @@ help: consider giving `b` an explicit type, where the placeholders `_` are speci
 LL |     let b: [_; 3];
    |          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/pattern/suggest-adding-appropriate-missing-pattern-excluding-comments.stderr b/tests/ui/pattern/suggest-adding-appropriate-missing-pattern-excluding-comments.stderr
index 5f2c89246e3..77d552b0cf6 100644
--- a/tests/ui/pattern/suggest-adding-appropriate-missing-pattern-excluding-comments.stderr
+++ b/tests/ui/pattern/suggest-adding-appropriate-missing-pattern-excluding-comments.stderr
@@ -16,6 +16,6 @@ LL ~         Some(_) => {},
 LL +         None => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr b/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr
index dbd46da4413..2352ecd0a47 100644
--- a/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr
+++ b/tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr
@@ -7,5 +7,5 @@ LL |     if let CONSTANT = &&MyType {
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/guards.stderr b/tests/ui/pattern/usefulness/guards.stderr
index fc6748958de..ad9046fe248 100644
--- a/tests/ui/pattern/usefulness/guards.stderr
+++ b/tests/ui/pattern/usefulness/guards.stderr
@@ -11,6 +11,6 @@ LL ~         128 ..= 255 if true => {},
 LL +         128_u8..=u8::MAX => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.allow.stderr b/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.allow.stderr
index 7f26c93aa28..9e35960bcda 100644
--- a/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.allow.stderr
+++ b/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.allow.stderr
@@ -12,6 +12,6 @@ LL +         _ => todo!(),
 LL +     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-105479-str-non-exhaustiveness.stderr b/tests/ui/pattern/usefulness/issue-105479-str-non-exhaustiveness.stderr
index 771fc320a13..96500ddb9cc 100644
--- a/tests/ui/pattern/usefulness/issue-105479-str-non-exhaustiveness.stderr
+++ b/tests/ui/pattern/usefulness/issue-105479-str-non-exhaustiveness.stderr
@@ -12,6 +12,6 @@ LL ~         ("c", "d") => {},
 LL +         (&_, _) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-12116.stderr b/tests/ui/pattern/usefulness/issue-12116.stderr
index 7f15c4703a3..199bdc6ac97 100644
--- a/tests/ui/pattern/usefulness/issue-12116.stderr
+++ b/tests/ui/pattern/usefulness/issue-12116.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/issue-12369.stderr b/tests/ui/pattern/usefulness/issue-12369.stderr
index aab2be78c9a..2b6e2e14b7c 100644
--- a/tests/ui/pattern/usefulness/issue-12369.stderr
+++ b/tests/ui/pattern/usefulness/issue-12369.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/issue-13727.stderr b/tests/ui/pattern/usefulness/issue-13727.stderr
index 07ca56a566f..ab80c56ea88 100644
--- a/tests/ui/pattern/usefulness/issue-13727.stderr
+++ b/tests/ui/pattern/usefulness/issue-13727.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/issue-15129.stderr b/tests/ui/pattern/usefulness/issue-15129.stderr
index ee8410b7650..cd6c3051196 100644
--- a/tests/ui/pattern/usefulness/issue-15129.stderr
+++ b/tests/ui/pattern/usefulness/issue-15129.stderr
@@ -11,6 +11,6 @@ LL ~         (T::T2(()), V::V2(b)) => (),
 LL ~         (T::T1(()), V::V2(_)) | (T::T2(()), V::V1(_)) => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-2111.stderr b/tests/ui/pattern/usefulness/issue-2111.stderr
index 7f7c5a0f19d..18ce7cc58c5 100644
--- a/tests/ui/pattern/usefulness/issue-2111.stderr
+++ b/tests/ui/pattern/usefulness/issue-2111.stderr
@@ -11,6 +11,6 @@ LL ~         (Some(_), None) | (None, Some(_)) => {},
 LL +         (None, None) | (Some(_), Some(_)) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-30240-b.stderr b/tests/ui/pattern/usefulness/issue-30240-b.stderr
index 59d64bc256b..74d39eba98c 100644
--- a/tests/ui/pattern/usefulness/issue-30240-b.stderr
+++ b/tests/ui/pattern/usefulness/issue-30240-b.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/issue-3096-1.stderr b/tests/ui/pattern/usefulness/issue-3096-1.stderr
index d8884394f8e..8a81116f0dd 100644
--- a/tests/ui/pattern/usefulness/issue-3096-1.stderr
+++ b/tests/ui/pattern/usefulness/issue-3096-1.stderr
@@ -12,6 +12,6 @@ LL +         _ => todo!(),
 LL ~     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-3096-2.stderr b/tests/ui/pattern/usefulness/issue-3096-2.stderr
index 2df8911badc..3eff2ee9bb1 100644
--- a/tests/ui/pattern/usefulness/issue-3096-2.stderr
+++ b/tests/ui/pattern/usefulness/issue-3096-2.stderr
@@ -12,6 +12,6 @@ LL +         _ => todo!(),
 LL ~     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-31561.stderr b/tests/ui/pattern/usefulness/issue-31561.stderr
index 5367de5e513..cc720565828 100644
--- a/tests/ui/pattern/usefulness/issue-31561.stderr
+++ b/tests/ui/pattern/usefulness/issue-31561.stderr
@@ -22,6 +22,6 @@ help: you might want to use `let else` to handle the variants that aren't matche
 LL |     let Thing::Foo(y) = Thing::Foo(1) else { todo!() };
    |                                       ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/pattern/usefulness/issue-3601.stderr b/tests/ui/pattern/usefulness/issue-3601.stderr
index b8c98743101..ce18b736c10 100644
--- a/tests/ui/pattern/usefulness/issue-3601.stderr
+++ b/tests/ui/pattern/usefulness/issue-3601.stderr
@@ -14,6 +14,6 @@ LL ~             box ElementKind::HTMLImageElement(ref d) if d.image.is_some() =
 LL ~             box _ => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-39362.stderr b/tests/ui/pattern/usefulness/issue-39362.stderr
index 8dc53491606..9cce87a1c65 100644
--- a/tests/ui/pattern/usefulness/issue-39362.stderr
+++ b/tests/ui/pattern/usefulness/issue-39362.stderr
@@ -18,6 +18,6 @@ LL ~         Foo::Bar { bar: Bar::B, .. } => (),
 LL ~         _ => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-40221.stderr b/tests/ui/pattern/usefulness/issue-40221.stderr
index 40b42af26b3..894cb95c7bb 100644
--- a/tests/ui/pattern/usefulness/issue-40221.stderr
+++ b/tests/ui/pattern/usefulness/issue-40221.stderr
@@ -18,6 +18,6 @@ LL ~         P::C(PC::Q) => (),
 LL ~         P::C(PC::QA) => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-4321.stderr b/tests/ui/pattern/usefulness/issue-4321.stderr
index 29327317410..a38f360c88a 100644
--- a/tests/ui/pattern/usefulness/issue-4321.stderr
+++ b/tests/ui/pattern/usefulness/issue-4321.stderr
@@ -11,6 +11,6 @@ LL ~         (true, true) => "baz",
 LL +         (true, false) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-50900.stderr b/tests/ui/pattern/usefulness/issue-50900.stderr
index 7880c892567..90df1fb7644 100644
--- a/tests/ui/pattern/usefulness/issue-50900.stderr
+++ b/tests/ui/pattern/usefulness/issue-50900.stderr
@@ -16,6 +16,6 @@ LL ~         Tag::ExifIFDPointer => {},
 LL +         Tag(Context::Exif, _) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-56379.stderr b/tests/ui/pattern/usefulness/issue-56379.stderr
index 50e13bdfdfe..ea21ee4e504 100644
--- a/tests/ui/pattern/usefulness/issue-56379.stderr
+++ b/tests/ui/pattern/usefulness/issue-56379.stderr
@@ -22,6 +22,6 @@ LL ~         Foo::C(true) => {},
 LL +         Foo::A(false) | Foo::B(false) | Foo::C(false) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-72377.stderr b/tests/ui/pattern/usefulness/issue-72377.stderr
index 123dd051d24..1eaee1bd352 100644
--- a/tests/ui/pattern/usefulness/issue-72377.stderr
+++ b/tests/ui/pattern/usefulness/issue-72377.stderr
@@ -11,6 +11,6 @@ LL ~         (X::A, Some(X::C)) | (X::C, Some(X::A)) => false,
 LL ~         _ => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-78123-non-exhaustive-reference.stderr b/tests/ui/pattern/usefulness/issue-78123-non-exhaustive-reference.stderr
index bf05d616d6e..2acde849650 100644
--- a/tests/ui/pattern/usefulness/issue-78123-non-exhaustive-reference.stderr
+++ b/tests/ui/pattern/usefulness/issue-78123-non-exhaustive-reference.stderr
@@ -18,6 +18,6 @@ LL +         _ => todo!(),
 LL +     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/issue-82772-match-box-as-struct.stderr b/tests/ui/pattern/usefulness/issue-82772-match-box-as-struct.stderr
index 2c8c85bb1e0..ba7573839ed 100644
--- a/tests/ui/pattern/usefulness/issue-82772-match-box-as-struct.stderr
+++ b/tests/ui/pattern/usefulness/issue-82772-match-box-as-struct.stderr
@@ -4,6 +4,6 @@ error[E0451]: field `1` of struct `Box` is private
 LL |     let Box { 1: _, .. }: Box<()>;
    |               ^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0451`.
diff --git a/tests/ui/pattern/usefulness/match-privately-empty.stderr b/tests/ui/pattern/usefulness/match-privately-empty.stderr
index 45352f09417..d760790dff6 100644
--- a/tests/ui/pattern/usefulness/match-privately-empty.stderr
+++ b/tests/ui/pattern/usefulness/match-privately-empty.stderr
@@ -16,6 +16,6 @@ LL ~         }) => {},
 LL +         Some(Private { misc: true, .. }) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/match-ref-ice.stderr b/tests/ui/pattern/usefulness/match-ref-ice.stderr
index fad0940baa4..0dbfa776f69 100644
--- a/tests/ui/pattern/usefulness/match-ref-ice.stderr
+++ b/tests/ui/pattern/usefulness/match-ref-ice.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/match-slice-patterns.stderr b/tests/ui/pattern/usefulness/match-slice-patterns.stderr
index 63d1f38e9db..30828ab6c90 100644
--- a/tests/ui/pattern/usefulness/match-slice-patterns.stderr
+++ b/tests/ui/pattern/usefulness/match-slice-patterns.stderr
@@ -11,6 +11,6 @@ LL ~         &[.., Some(_), _] => {},
 LL ~         &[_, Some(_), .., None, _] => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/nested-non-exhaustive-enums.stderr b/tests/ui/pattern/usefulness/nested-non-exhaustive-enums.stderr
index 9fbd871db7c..a966444159b 100644
--- a/tests/ui/pattern/usefulness/nested-non-exhaustive-enums.stderr
+++ b/tests/ui/pattern/usefulness/nested-non-exhaustive-enums.stderr
@@ -17,6 +17,6 @@ LL ~         None => {},
 LL +         Some(_) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/refutable-pattern-in-fn-arg.stderr b/tests/ui/pattern/usefulness/refutable-pattern-in-fn-arg.stderr
index 01f077909e8..bd6c5002e63 100644
--- a/tests/ui/pattern/usefulness/refutable-pattern-in-fn-arg.stderr
+++ b/tests/ui/pattern/usefulness/refutable-pattern-in-fn-arg.stderr
@@ -10,6 +10,6 @@ help: alternatively, you could prepend the pattern with an underscore to define
 LL |     let f = |_3: isize| println!("hello");
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/pattern/usefulness/struct-like-enum-nonexhaustive.stderr b/tests/ui/pattern/usefulness/struct-like-enum-nonexhaustive.stderr
index 3d2b540a9f5..17d937bd528 100644
--- a/tests/ui/pattern/usefulness/struct-like-enum-nonexhaustive.stderr
+++ b/tests/ui/pattern/usefulness/struct-like-enum-nonexhaustive.stderr
@@ -18,6 +18,6 @@ LL ~         A::B { x: None } => {},
 LL +         A::B { x: Some(_) } => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr b/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr
index fbee33de6f3..cc29c42e4d6 100644
--- a/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr
+++ b/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/tuple-struct-nonexhaustive.stderr b/tests/ui/pattern/usefulness/tuple-struct-nonexhaustive.stderr
index ef707ed4aa4..0b21bd3f5f0 100644
--- a/tests/ui/pattern/usefulness/tuple-struct-nonexhaustive.stderr
+++ b/tests/ui/pattern/usefulness/tuple-struct-nonexhaustive.stderr
@@ -16,6 +16,6 @@ LL ~         Foo(2, b) => println!("{}", b),
 LL +         Foo(..=0_isize, _) | Foo(3_isize.., _) => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/unstable-gated-patterns.stderr b/tests/ui/pattern/usefulness/unstable-gated-patterns.stderr
index 4a4945156f7..5f3e5a7398d 100644
--- a/tests/ui/pattern/usefulness/unstable-gated-patterns.stderr
+++ b/tests/ui/pattern/usefulness/unstable-gated-patterns.stderr
@@ -19,6 +19,6 @@ LL ~         UnstableEnum::Stable2 => {},
 LL +         UnstableEnum::Unstable => todo!()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/pin-macro/cant_access_internals.stderr b/tests/ui/pin-macro/cant_access_internals.stderr
index d43027657f0..9af1cd2a16c 100644
--- a/tests/ui/pin-macro/cant_access_internals.stderr
+++ b/tests/ui/pin-macro/cant_access_internals.stderr
@@ -6,6 +6,6 @@ LL |     mem::take(phantom_pinned.pointer);
    |
    = help: add `#![feature(unsafe_pin_internals)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/point-to-type-err-cause-on-impl-trait-return-2.stderr b/tests/ui/point-to-type-err-cause-on-impl-trait-return-2.stderr
index a8d0d623604..34aaea5b70b 100644
--- a/tests/ui/point-to-type-err-cause-on-impl-trait-return-2.stderr
+++ b/tests/ui/point-to-type-err-cause-on-impl-trait-return-2.stderr
@@ -7,6 +7,6 @@ LL |             let value: &bool = unsafe { &42 };
    = note: expected reference `&bool`
               found reference `&{integer}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/polymorphization/const_parameters/functions.stderr b/tests/ui/polymorphization/const_parameters/functions.stderr
index 9d0922ac7ca..a3033d1dcab 100644
--- a/tests/ui/polymorphization/const_parameters/functions.stderr
+++ b/tests/ui/polymorphization/const_parameters/functions.stderr
@@ -13,5 +13,5 @@ error: item has unused generic parameters
 LL | pub fn unused<const T: usize>() {
    |        ^^^^^^ -------------- generic parameter `T` is unused
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/polymorphization/promoted-function-1.stderr b/tests/ui/polymorphization/promoted-function-1.stderr
index fcbb8694923..8ab0320aafe 100644
--- a/tests/ui/polymorphization/promoted-function-1.stderr
+++ b/tests/ui/polymorphization/promoted-function-1.stderr
@@ -4,5 +4,5 @@ error: item has unused generic parameters
 LL | pub fn test<T>() {
    |        ^^^^ - generic parameter `T` is unused
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/polymorphization/promoted-function-2.stderr b/tests/ui/polymorphization/promoted-function-2.stderr
index 547569df7dc..a5d3bee11d9 100644
--- a/tests/ui/polymorphization/promoted-function-2.stderr
+++ b/tests/ui/polymorphization/promoted-function-2.stderr
@@ -13,5 +13,5 @@ error: item has unused generic parameters
 LL | fn test<T>() {
    |    ^^^^ - generic parameter `T` is unused
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/privacy/decl-macro.stderr b/tests/ui/privacy/decl-macro.stderr
index 5bc6f07fffa..1ca75ec36ca 100644
--- a/tests/ui/privacy/decl-macro.stderr
+++ b/tests/ui/privacy/decl-macro.stderr
@@ -10,6 +10,6 @@ note: the macro `mac` is defined here
 LL |     macro mac() {}
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/export-tag-variant.stderr b/tests/ui/privacy/export-tag-variant.stderr
index e8906985e05..778ded2df99 100644
--- a/tests/ui/privacy/export-tag-variant.stderr
+++ b/tests/ui/privacy/export-tag-variant.stderr
@@ -12,6 +12,6 @@ note: the enum `Y` is defined here
 LL |     enum Y { Y1 }
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/issue-111220-2-tuple-struct-fields-projection.stderr b/tests/ui/privacy/issue-111220-2-tuple-struct-fields-projection.stderr
index 231a4da8b5f..eda42c24c1e 100644
--- a/tests/ui/privacy/issue-111220-2-tuple-struct-fields-projection.stderr
+++ b/tests/ui/privacy/issue-111220-2-tuple-struct-fields-projection.stderr
@@ -4,6 +4,6 @@ error[E0603]: tuple struct constructor `A` is private
 LL |         let Self(a) = self;
    |             ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/issue-75062-fieldless-tuple-struct.stderr b/tests/ui/privacy/issue-75062-fieldless-tuple-struct.stderr
index 14a12003e2d..b00e566f8f9 100644
--- a/tests/ui/privacy/issue-75062-fieldless-tuple-struct.stderr
+++ b/tests/ui/privacy/issue-75062-fieldless-tuple-struct.stderr
@@ -10,6 +10,6 @@ note: the tuple struct `Bar` is defined here
 LL |     struct Bar();
    |     ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/issue-75906.stderr b/tests/ui/privacy/issue-75906.stderr
index 600dc7c876f..c5bbef97c34 100644
--- a/tests/ui/privacy/issue-75906.stderr
+++ b/tests/ui/privacy/issue-75906.stderr
@@ -14,6 +14,6 @@ help: consider making the field publicly accessible
 LL |     pub struct Bar(pub u8);
    |                    +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/privacy/legacy-ctor-visibility.stderr b/tests/ui/privacy/legacy-ctor-visibility.stderr
index c8057d85ed1..78c79fc951e 100644
--- a/tests/ui/privacy/legacy-ctor-visibility.stderr
+++ b/tests/ui/privacy/legacy-ctor-visibility.stderr
@@ -4,6 +4,6 @@ error[E0423]: expected function, tuple struct or tuple variant, found struct `S`
 LL |             S(10);
    |             ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/privacy/privacy-ufcs.stderr b/tests/ui/privacy/privacy-ufcs.stderr
index f45f3d8ec37..5c986895d64 100644
--- a/tests/ui/privacy/privacy-ufcs.stderr
+++ b/tests/ui/privacy/privacy-ufcs.stderr
@@ -12,6 +12,6 @@ note: the trait `Bar` is defined here
 LL |     trait Bar {
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/privacy4.stderr b/tests/ui/privacy/privacy4.stderr
index 7552fa71a3a..4aa3ae964c0 100644
--- a/tests/ui/privacy/privacy4.stderr
+++ b/tests/ui/privacy/privacy4.stderr
@@ -10,6 +10,6 @@ note: the module `glob` is defined here
 LL |     mod glob {
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/private-field-ty-err.stderr b/tests/ui/privacy/private-field-ty-err.stderr
index 98ba7856e57..17d50f24a94 100644
--- a/tests/ui/privacy/private-field-ty-err.stderr
+++ b/tests/ui/privacy/private-field-ty-err.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `len` of struct `Foo` is private
 LL |     if x.len {
    |          ^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/privacy/private-impl-method.stderr b/tests/ui/privacy/private-impl-method.stderr
index 18e4531d112..c53232e4c8c 100644
--- a/tests/ui/privacy/private-impl-method.stderr
+++ b/tests/ui/privacy/private-impl-method.stderr
@@ -7,6 +7,6 @@ LL |         fn foo(&self) {}
 LL |     s.foo();
    |       ^^^ private method
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/privacy/private-in-public-non-principal-2.stderr b/tests/ui/privacy/private-in-public-non-principal-2.stderr
index 7cc8bf0de2b..d3da2326abc 100644
--- a/tests/ui/privacy/private-in-public-non-principal-2.stderr
+++ b/tests/ui/privacy/private-in-public-non-principal-2.stderr
@@ -4,5 +4,5 @@ error: trait `PrivNonPrincipal` is private
 LL |     m::leak_dyn_nonprincipal();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ private trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/privacy/private-in-public-non-principal.stderr b/tests/ui/privacy/private-in-public-non-principal.stderr
index 63512f462f5..73f2249bc6c 100644
--- a/tests/ui/privacy/private-in-public-non-principal.stderr
+++ b/tests/ui/privacy/private-in-public-non-principal.stderr
@@ -23,5 +23,5 @@ note: the lint level is defined here
 LL | #[deny(missing_docs)]
    |        ^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/privacy/private-item-simple.stderr b/tests/ui/privacy/private-item-simple.stderr
index e3d90150e2e..330d892e939 100644
--- a/tests/ui/privacy/private-item-simple.stderr
+++ b/tests/ui/privacy/private-item-simple.stderr
@@ -10,6 +10,6 @@ note: the function `f` is defined here
 LL |     fn f() {}
    |     ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/private-method-cross-crate.stderr b/tests/ui/privacy/private-method-cross-crate.stderr
index e644440c827..9c524e2bd37 100644
--- a/tests/ui/privacy/private-method-cross-crate.stderr
+++ b/tests/ui/privacy/private-method-cross-crate.stderr
@@ -9,6 +9,6 @@ LL |   nyan.nap();
 LL |         fn nap(&self) {}
    |         ------------- private method defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/privacy/private-method-inherited.stderr b/tests/ui/privacy/private-method-inherited.stderr
index 0104a1b27e4..dd36afe8b36 100644
--- a/tests/ui/privacy/private-method-inherited.stderr
+++ b/tests/ui/privacy/private-method-inherited.stderr
@@ -7,6 +7,6 @@ LL |         fn f(self) {}
 LL |     x.f();
    |       ^ private method
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/privacy/private-method.stderr b/tests/ui/privacy/private-method.stderr
index 42fec762265..076a149e1a1 100644
--- a/tests/ui/privacy/private-method.stderr
+++ b/tests/ui/privacy/private-method.stderr
@@ -7,6 +7,6 @@ LL |         fn nap(&self) {}
 LL |   nyan.nap();
    |        ^^^ private method
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/privacy/private-struct-field-cross-crate.stderr b/tests/ui/privacy/private-struct-field-cross-crate.stderr
index 40cf3448d6f..ed4c83f159b 100644
--- a/tests/ui/privacy/private-struct-field-cross-crate.stderr
+++ b/tests/ui/privacy/private-struct-field-cross-crate.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `meows` of struct `cat` is private
 LL |   assert_eq!(nyan.meows, 52);
    |                   ^^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/privacy/private-struct-field-ctor.stderr b/tests/ui/privacy/private-struct-field-ctor.stderr
index 9dc9db0eaca..2a35537237a 100644
--- a/tests/ui/privacy/private-struct-field-ctor.stderr
+++ b/tests/ui/privacy/private-struct-field-ctor.stderr
@@ -4,6 +4,6 @@ error[E0451]: field `x` of struct `Foo` is private
 LL |     let s = a::Foo { x: 1 };
    |                      ^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0451`.
diff --git a/tests/ui/privacy/private-struct-field-pattern.stderr b/tests/ui/privacy/private-struct-field-pattern.stderr
index 63055303683..de24d1e0962 100644
--- a/tests/ui/privacy/private-struct-field-pattern.stderr
+++ b/tests/ui/privacy/private-struct-field-pattern.stderr
@@ -4,6 +4,6 @@ error[E0451]: field `x` of struct `Foo` is private
 LL |         Foo { x: _ } => {}
    |               ^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0451`.
diff --git a/tests/ui/privacy/private-struct-field.stderr b/tests/ui/privacy/private-struct-field.stderr
index facf4e82fd6..cc5a966bc9b 100644
--- a/tests/ui/privacy/private-struct-field.stderr
+++ b/tests/ui/privacy/private-struct-field.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `meows` of struct `Cat` is private
 LL |     assert_eq!(nyan.meows, 52);
    |                     ^^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/privacy/restricted/struct-literal-field.stderr b/tests/ui/privacy/restricted/struct-literal-field.stderr
index eee964f022a..dcdadf1da4b 100644
--- a/tests/ui/privacy/restricted/struct-literal-field.stderr
+++ b/tests/ui/privacy/restricted/struct-literal-field.stderr
@@ -4,6 +4,6 @@ error[E0451]: field `x` of struct `S` is private
 LL |     S { x: 0 };
    |         ^^^^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0451`.
diff --git a/tests/ui/privacy/sealed-traits/private-trait-non-local.stderr b/tests/ui/privacy/sealed-traits/private-trait-non-local.stderr
index 29499979866..e6b76322f96 100644
--- a/tests/ui/privacy/sealed-traits/private-trait-non-local.stderr
+++ b/tests/ui/privacy/sealed-traits/private-trait-non-local.stderr
@@ -7,6 +7,6 @@ LL | use core::slice::index::private_slice_index::Sealed;
 note: the module `index` is defined here
   --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/sealed-traits/private-trait.stderr b/tests/ui/privacy/sealed-traits/private-trait.stderr
index c7ec72ff166..e8d88906f1f 100644
--- a/tests/ui/privacy/sealed-traits/private-trait.stderr
+++ b/tests/ui/privacy/sealed-traits/private-trait.stderr
@@ -12,6 +12,6 @@ note: the module `b` is defined here
 LL |     mod b {
    |     ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/sealed-traits/re-exported-trait.stderr b/tests/ui/privacy/sealed-traits/re-exported-trait.stderr
index b630565d023..9f2291e6825 100644
--- a/tests/ui/privacy/sealed-traits/re-exported-trait.stderr
+++ b/tests/ui/privacy/sealed-traits/re-exported-trait.stderr
@@ -14,6 +14,6 @@ help: consider importing this trait through its public re-export instead
 LL | impl a::Trait for S {}
    |      ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/privacy/union-field-privacy-2.stderr b/tests/ui/privacy/union-field-privacy-2.stderr
index bf6a2b625d5..7b6b84bfd4c 100644
--- a/tests/ui/privacy/union-field-privacy-2.stderr
+++ b/tests/ui/privacy/union-field-privacy-2.stderr
@@ -4,6 +4,6 @@ error[E0616]: field `c` of union `U` is private
 LL |     let c = u.c;
    |               ^ private field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/privacy/where-priv-type.stderr b/tests/ui/privacy/where-priv-type.stderr
index 65076645846..126330b14a6 100644
--- a/tests/ui/privacy/where-priv-type.stderr
+++ b/tests/ui/privacy/where-priv-type.stderr
@@ -77,6 +77,6 @@ LL |     type AssocTy = Const<{ my_const_fn(U) }>;
 LL | const fn my_const_fn(val: u8) -> u8 {
    | ----------------------------------- `fn(u8) -> u8 {my_const_fn}` declared as private
 
-error: aborting due to previous error; 5 warnings emitted
+error: aborting due to 1 previous error; 5 warnings emitted
 
 For more information about this error, try `rustc --explain E0446`.
diff --git a/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr b/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr
index 316eb636ba8..346cebf639d 100644
--- a/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr
+++ b/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `NonExistent` in this scope
 LL |     NonExistent;
    |     ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/proc-macro/cfg-eval-fail.stderr b/tests/ui/proc-macro/cfg-eval-fail.stderr
index df8b6d5f382..945ad46bf33 100644
--- a/tests/ui/proc-macro/cfg-eval-fail.stderr
+++ b/tests/ui/proc-macro/cfg-eval-fail.stderr
@@ -4,5 +4,5 @@ error: removing an expression is not supported in this position
 LL |     let _ = #[cfg_eval] #[cfg(FALSE)] 0;
    |                         ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/define-two.stderr b/tests/ui/proc-macro/define-two.stderr
index bf1bd8427c8..a39ce366f75 100644
--- a/tests/ui/proc-macro/define-two.stderr
+++ b/tests/ui/proc-macro/define-two.stderr
@@ -9,6 +9,6 @@ LL | #[proc_macro_derive(A)]
    |
    = note: `A` must be defined only once in the macro namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/proc-macro/derive-helper-legacy-limits.stderr b/tests/ui/proc-macro/derive-helper-legacy-limits.stderr
index 186f38a00f9..f5cd455435d 100644
--- a/tests/ui/proc-macro/derive-helper-legacy-limits.stderr
+++ b/tests/ui/proc-macro/derive-helper-legacy-limits.stderr
@@ -4,5 +4,5 @@ error: cannot find attribute `empty_helper` in this scope
 LL | #[empty_helper]
    |   ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/derive-still-gated.stderr b/tests/ui/proc-macro/derive-still-gated.stderr
index 99289fdfe7f..25777f72b8d 100644
--- a/tests/ui/proc-macro/derive-still-gated.stderr
+++ b/tests/ui/proc-macro/derive-still-gated.stderr
@@ -4,5 +4,5 @@ error: cannot find attribute `derive_Empty` in this scope
 LL | #[derive_Empty]
    |   ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/edition-gated-async-move-syntax-issue89699.stderr b/tests/ui/proc-macro/edition-gated-async-move-syntax-issue89699.stderr
index a0dcc84eef8..5123b823fb8 100644
--- a/tests/ui/proc-macro/edition-gated-async-move-syntax-issue89699.stderr
+++ b/tests/ui/proc-macro/edition-gated-async-move-syntax-issue89699.stderr
@@ -4,5 +4,5 @@ error: `async move` blocks are only allowed in Rust 2018 or later
 LL | fn foo() {}
    | ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/expand-to-unstable.stderr b/tests/ui/proc-macro/expand-to-unstable.stderr
index b27dcd7e6cd..dda590ee8c7 100644
--- a/tests/ui/proc-macro/expand-to-unstable.stderr
+++ b/tests/ui/proc-macro/expand-to-unstable.stderr
@@ -7,6 +7,6 @@ LL | #[derive(Unstable)]
    = help: add `#![feature(core_intrinsics)]` to the crate attributes to enable
    = note: this error originates in the derive macro `Unstable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/proc-macro/export-macro.stderr b/tests/ui/proc-macro/export-macro.stderr
index 36a6a9bb3e7..410770eca08 100644
--- a/tests/ui/proc-macro/export-macro.stderr
+++ b/tests/ui/proc-macro/export-macro.stderr
@@ -4,5 +4,5 @@ error: cannot export macro_rules! macros from a `proc-macro` crate type currentl
 LL | macro_rules! foo {
    | ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr b/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr
index 9441cdcc8cf..1c12a2804c6 100644
--- a/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr
+++ b/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr
@@ -30,6 +30,6 @@ LL | #[derive(Empty)]
    = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
    = note: `#[warn(legacy_derive_helpers)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/proc-macro/import.stderr b/tests/ui/proc-macro/import.stderr
index aae621193ab..c5d1648abfe 100644
--- a/tests/ui/proc-macro/import.stderr
+++ b/tests/ui/proc-macro/import.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `test_macros::empty_derive`
 LL | use test_macros::empty_derive;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ no `empty_derive` in the root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/proc-macro/invalid-punct-ident-1.stderr b/tests/ui/proc-macro/invalid-punct-ident-1.stderr
index 78aa84401a5..0013bfd16a8 100644
--- a/tests/ui/proc-macro/invalid-punct-ident-1.stderr
+++ b/tests/ui/proc-macro/invalid-punct-ident-1.stderr
@@ -6,5 +6,5 @@ LL | invalid_punct!();
    |
    = help: message: unsupported character `'`'`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/invalid-punct-ident-2.stderr b/tests/ui/proc-macro/invalid-punct-ident-2.stderr
index 66979e756ae..3de2139d5d7 100644
--- a/tests/ui/proc-macro/invalid-punct-ident-2.stderr
+++ b/tests/ui/proc-macro/invalid-punct-ident-2.stderr
@@ -6,5 +6,5 @@ LL | invalid_ident!();
    |
    = help: message: `"*"` is not a valid identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/invalid-punct-ident-3.stderr b/tests/ui/proc-macro/invalid-punct-ident-3.stderr
index c096bc8c043..158ba0d4fb7 100644
--- a/tests/ui/proc-macro/invalid-punct-ident-3.stderr
+++ b/tests/ui/proc-macro/invalid-punct-ident-3.stderr
@@ -6,5 +6,5 @@ LL | invalid_raw_ident!();
    |
    = help: message: `self` cannot be a raw identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/issue-107113-wrap.stderr b/tests/ui/proc-macro/issue-107113-wrap.stderr
index 4122253d22f..b541051147d 100644
--- a/tests/ui/proc-macro/issue-107113-wrap.stderr
+++ b/tests/ui/proc-macro/issue-107113-wrap.stderr
@@ -11,6 +11,6 @@ LL | #[issue_107113::main]
            found unit type `()`
    = note: this error originates in the attribute macro `issue_107113::main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/proc-macro/issue-37788.stderr b/tests/ui/proc-macro/issue-37788.stderr
index 0a116d6f80d..9ce783073fd 100644
--- a/tests/ui/proc-macro/issue-37788.stderr
+++ b/tests/ui/proc-macro/issue-37788.stderr
@@ -12,6 +12,6 @@ LL |     std::cell::Cell::new(0)
    = note: expected unit type `()`
                  found struct `Cell<{integer}>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/proc-macro/issue-38586.stderr b/tests/ui/proc-macro/issue-38586.stderr
index ddd0a0874dd..00491556450 100644
--- a/tests/ui/proc-macro/issue-38586.stderr
+++ b/tests/ui/proc-macro/issue-38586.stderr
@@ -6,6 +6,6 @@ LL | #[derive(A)]
    |
    = note: this error originates in the derive macro `A` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/proc-macro/issue-50493.stderr b/tests/ui/proc-macro/issue-50493.stderr
index 23e103dbfcb..1cd3583135b 100644
--- a/tests/ui/proc-macro/issue-50493.stderr
+++ b/tests/ui/proc-macro/issue-50493.stderr
@@ -4,6 +4,6 @@ error[E0742]: visibilities can only be restricted to ancestor modules
 LL |     pub(in restricted) field: usize,
    |            ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0742`.
diff --git a/tests/ui/proc-macro/issue-59191-replace-root-with-fn.stderr b/tests/ui/proc-macro/issue-59191-replace-root-with-fn.stderr
index f7516c7d377..08e679a7c55 100644
--- a/tests/ui/proc-macro/issue-59191-replace-root-with-fn.stderr
+++ b/tests/ui/proc-macro/issue-59191-replace-root-with-fn.stderr
@@ -1,4 +1,4 @@
 error: requires `sized` lang_item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/issue-66286.stderr b/tests/ui/proc-macro/issue-66286.stderr
index fe2464b3b81..fc4c2062fd7 100644
--- a/tests/ui/proc-macro/issue-66286.stderr
+++ b/tests/ui/proc-macro/issue-66286.stderr
@@ -9,6 +9,6 @@ help: use angle brackets instead
 LL | pub extern fn foo(_: Vec<u32>) -> u32 {
    |                         ~   ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0214`.
diff --git a/tests/ui/proc-macro/issue-75801.stderr b/tests/ui/proc-macro/issue-75801.stderr
index ee0a9bd7783..3b5f9e3b5b0 100644
--- a/tests/ui/proc-macro/issue-75801.stderr
+++ b/tests/ui/proc-macro/issue-75801.stderr
@@ -7,6 +7,6 @@ LL |             let _bar: u32 = $arg;
 LL | foo!("baz");
    |      ^^^^^ expected `u32`, found `&str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/proc-macro/issue-76270-panic-in-libproc-macro.stderr b/tests/ui/proc-macro/issue-76270-panic-in-libproc-macro.stderr
index d69de23a4c0..7bf85104db3 100644
--- a/tests/ui/proc-macro/issue-76270-panic-in-libproc-macro.stderr
+++ b/tests/ui/proc-macro/issue-76270-panic-in-libproc-macro.stderr
@@ -6,5 +6,5 @@ LL | proc_macro_panic::panic_in_libproc_macro!();
    |
    = help: message: `""` is not a valid identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/issue-79148.stderr b/tests/ui/proc-macro/issue-79148.stderr
index a3b2de01ddf..8adc4c6e0db 100644
--- a/tests/ui/proc-macro/issue-79148.stderr
+++ b/tests/ui/proc-macro/issue-79148.stderr
@@ -11,6 +11,6 @@ LL | cause_ice!();
    | ^^^^^^^^^^^^
    = note: this error originates in the macro `cause_ice` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0364`.
diff --git a/tests/ui/proc-macro/issue-81543-item-parse-err.stderr b/tests/ui/proc-macro/issue-81543-item-parse-err.stderr
index ca524176035..50f9c71eb28 100644
--- a/tests/ui/proc-macro/issue-81543-item-parse-err.stderr
+++ b/tests/ui/proc-macro/issue-81543-item-parse-err.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `32`
 LL |     fn 32() {}
    |        ^^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/issue-83469-global-alloc-invalid-stmt.stderr b/tests/ui/proc-macro/issue-83469-global-alloc-invalid-stmt.stderr
index ec0e3c4c754..02fcaf54297 100644
--- a/tests/ui/proc-macro/issue-83469-global-alloc-invalid-stmt.stderr
+++ b/tests/ui/proc-macro/issue-83469-global-alloc-invalid-stmt.stderr
@@ -4,5 +4,5 @@ error: allocators must be statics
 LL |     fn inner() {}
    |     ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/issue-86781-bad-inner-doc.stderr b/tests/ui/proc-macro/issue-86781-bad-inner-doc.stderr
index a92f07522e5..aeb824303e7 100644
--- a/tests/ui/proc-macro/issue-86781-bad-inner-doc.stderr
+++ b/tests/ui/proc-macro/issue-86781-bad-inner-doc.stderr
@@ -12,6 +12,6 @@ help: to annotate the struct, change the doc comment from inner to outer style
 LL | /// Inner doc comment
    |   ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0753`.
diff --git a/tests/ui/proc-macro/item-error.stderr b/tests/ui/proc-macro/item-error.stderr
index b544be6e96a..71d0ee10aa2 100644
--- a/tests/ui/proc-macro/item-error.stderr
+++ b/tests/ui/proc-macro/item-error.stderr
@@ -10,6 +10,6 @@ LL ~ struct A<'a> {
 LL ~     a: &'a u64
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/proc-macro/lifetimes.stderr b/tests/ui/proc-macro/lifetimes.stderr
index 0c99809ed5c..315b4c59172 100644
--- a/tests/ui/proc-macro/lifetimes.stderr
+++ b/tests/ui/proc-macro/lifetimes.stderr
@@ -9,5 +9,5 @@ LL | type A = single_quote_alone!();
    |
    = note: this error originates in the macro `single_quote_alone` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/lints_in_proc_macros.stderr b/tests/ui/proc-macro/lints_in_proc_macros.stderr
index 4dd8be7d9b6..244d218608b 100644
--- a/tests/ui/proc-macro/lints_in_proc_macros.stderr
+++ b/tests/ui/proc-macro/lints_in_proc_macros.stderr
@@ -6,6 +6,6 @@ LL |     bang_proc_macro2!();
    |
    = note: this error originates in the macro `bang_proc_macro2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/proc-macro/load-panic-backtrace.stderr b/tests/ui/proc-macro/load-panic-backtrace.stderr
index c1a642713d2..18f51358672 100644
--- a/tests/ui/proc-macro/load-panic-backtrace.stderr
+++ b/tests/ui/proc-macro/load-panic-backtrace.stderr
@@ -8,5 +8,5 @@ LL | #[derive(Panic)]
    |
    = help: message: panic-derive
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/load-panic.stderr b/tests/ui/proc-macro/load-panic.stderr
index f0d62f690fd..bb429ad631d 100644
--- a/tests/ui/proc-macro/load-panic.stderr
+++ b/tests/ui/proc-macro/load-panic.stderr
@@ -6,5 +6,5 @@ LL | #[derive(Panic)]
    |
    = help: message: panic-derive
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/macro-brackets.stderr b/tests/ui/proc-macro/macro-brackets.stderr
index d3516375291..f14b5fed6b9 100644
--- a/tests/ui/proc-macro/macro-brackets.stderr
+++ b/tests/ui/proc-macro/macro-brackets.stderr
@@ -9,6 +9,6 @@ help: you can cast a `char` to a `u32`, since a `char` always occupies 4 bytes
 LL | id![static X: u32 = 'a' as u32;];
    |                         ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/proc-macro/macro-rules-derive.stderr b/tests/ui/proc-macro/macro-rules-derive.stderr
index 517cbabd5c6..e7cd4474618 100644
--- a/tests/ui/proc-macro/macro-rules-derive.stderr
+++ b/tests/ui/proc-macro/macro-rules-derive.stderr
@@ -9,6 +9,6 @@ LL | produce_it!(MyName);
    |
    = note: this error originates in the macro `produce_it` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/proc-macro/macros-in-extern-derive.stderr b/tests/ui/proc-macro/macros-in-extern-derive.stderr
index efd9ff22506..c7d2881ad21 100644
--- a/tests/ui/proc-macro/macros-in-extern-derive.stderr
+++ b/tests/ui/proc-macro/macros-in-extern-derive.stderr
@@ -6,6 +6,6 @@ LL |     #[derive(Copy)]
 LL |     fn f();
    |     ------- not a `struct`, `enum` or `union`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0774`.
diff --git a/tests/ui/proc-macro/no-macro-use-attr.stderr b/tests/ui/proc-macro/no-macro-use-attr.stderr
index a9e5256a0a9..3dda3cc7d5a 100644
--- a/tests/ui/proc-macro/no-macro-use-attr.stderr
+++ b/tests/ui/proc-macro/no-macro-use-attr.stderr
@@ -16,5 +16,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {}
    | ^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/proc-macro/non-root.stderr b/tests/ui/proc-macro/non-root.stderr
index 90f94b677e9..ecc0202c106 100644
--- a/tests/ui/proc-macro/non-root.stderr
+++ b/tests/ui/proc-macro/non-root.stderr
@@ -4,5 +4,5 @@ error: functions tagged with `#[proc_macro]` must currently reside in the root o
 LL |     pub fn foo(arg: TokenStream) -> TokenStream { arg }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/raw-ident.stderr b/tests/ui/proc-macro/raw-ident.stderr
index 905a5f9463a..a72067021cb 100644
--- a/tests/ui/proc-macro/raw-ident.stderr
+++ b/tests/ui/proc-macro/raw-ident.stderr
@@ -6,5 +6,5 @@ LL |     make_bad_struct!(S);
    |
    = note: this error originates in the macro `make_bad_struct` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/shadow.stderr b/tests/ui/proc-macro/shadow.stderr
index e7d95cc8358..6f50d89f500 100644
--- a/tests/ui/proc-macro/shadow.stderr
+++ b/tests/ui/proc-macro/shadow.stderr
@@ -9,6 +9,6 @@ LL | extern crate test_macros;
    |
    = note: `test_macros` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/proc-macro/signature.stderr b/tests/ui/proc-macro/signature.stderr
index ba5c8c1571e..2a53145a643 100644
--- a/tests/ui/proc-macro/signature.stderr
+++ b/tests/ui/proc-macro/signature.stderr
@@ -7,5 +7,5 @@ LL | pub unsafe extern "C" fn foo(a: i32, b: u32) -> u32 {
    = note: expected signature `fn(proc_macro::TokenStream) -> proc_macro::TokenStream`
               found signature `unsafe extern "C" fn(i32, u32) -> u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/test-same-crate.stderr b/tests/ui/proc-macro/test-same-crate.stderr
index 5d12e149c3c..3cab0ae6790 100644
--- a/tests/ui/proc-macro/test-same-crate.stderr
+++ b/tests/ui/proc-macro/test-same-crate.stderr
@@ -6,5 +6,5 @@ LL |     fn t() { crate::mac!(A) }
    |
    = help: you can define integration tests in a directory named `tests`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/two-crate-types-1.stderr b/tests/ui/proc-macro/two-crate-types-1.stderr
index deaba1cf272..a7524fd3b0a 100644
--- a/tests/ui/proc-macro/two-crate-types-1.stderr
+++ b/tests/ui/proc-macro/two-crate-types-1.stderr
@@ -1,4 +1,4 @@
 error: cannot mix `proc-macro` crate type with others
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/proc-macro/two-crate-types-2.stderr b/tests/ui/proc-macro/two-crate-types-2.stderr
index deaba1cf272..a7524fd3b0a 100644
--- a/tests/ui/proc-macro/two-crate-types-2.stderr
+++ b/tests/ui/proc-macro/two-crate-types-2.stderr
@@ -1,4 +1,4 @@
 error: cannot mix `proc-macro` crate type with others
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-fn-2.stderr b/tests/ui/pub/pub-ident-fn-2.stderr
index b5b667b41b6..e724278b233 100644
--- a/tests/ui/pub/pub-ident-fn-2.stderr
+++ b/tests/ui/pub/pub-ident-fn-2.stderr
@@ -9,5 +9,5 @@ help: add `fn` here to parse `foo` as a public function
 LL | pub fn foo(_s: usize) { bar() }
    |     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-fn-or-struct.stderr b/tests/ui/pub/pub-ident-fn-or-struct.stderr
index c4a196eb2c2..a8fa4bd3bd3 100644
--- a/tests/ui/pub/pub-ident-fn-or-struct.stderr
+++ b/tests/ui/pub/pub-ident-fn-or-struct.stderr
@@ -4,5 +4,5 @@ error: missing `fn` or `struct` for function or struct definition
 LL | pub S (foo) bar
    | ---^- help: if you meant to call a macro, try: `S!`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-fn-with-lifetime-2.stderr b/tests/ui/pub/pub-ident-fn-with-lifetime-2.stderr
index 6a9aeaf4a56..b0d5ce9de5c 100644
--- a/tests/ui/pub/pub-ident-fn-with-lifetime-2.stderr
+++ b/tests/ui/pub/pub-ident-fn-with-lifetime-2.stderr
@@ -9,5 +9,5 @@ help: add `fn` here to parse `bar` as a public method
 LL | pub fn bar<'a>(&self, _s: &'a usize) -> bool { true }
    |     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-fn-with-lifetime.stderr b/tests/ui/pub/pub-ident-fn-with-lifetime.stderr
index c1ca0136b18..63fcf6bf5d5 100644
--- a/tests/ui/pub/pub-ident-fn-with-lifetime.stderr
+++ b/tests/ui/pub/pub-ident-fn-with-lifetime.stderr
@@ -9,5 +9,5 @@ help: add `fn` here to parse `foo` as a public function
 LL | pub fn foo<'a>(_s: &'a usize) -> bool { true }
    |     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-fn.stderr b/tests/ui/pub/pub-ident-fn.stderr
index cb94c48add4..06dac616443 100644
--- a/tests/ui/pub/pub-ident-fn.stderr
+++ b/tests/ui/pub/pub-ident-fn.stderr
@@ -9,5 +9,5 @@ help: add `fn` here to parse `foo` as a public function
 LL | pub fn foo(_s: usize) -> bool { true }
    |     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-struct-2.stderr b/tests/ui/pub/pub-ident-struct-2.stderr
index 6969a376a5e..5e0f328d986 100644
--- a/tests/ui/pub/pub-ident-struct-2.stderr
+++ b/tests/ui/pub/pub-ident-struct-2.stderr
@@ -9,5 +9,5 @@ help: add `struct` here to parse `bar` as a public struct
 LL |     pub struct bar();
    |         ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-struct-3.stderr b/tests/ui/pub/pub-ident-struct-3.stderr
index d94198a6b6d..d08e5120570 100644
--- a/tests/ui/pub/pub-ident-struct-3.stderr
+++ b/tests/ui/pub/pub-ident-struct-3.stderr
@@ -9,5 +9,5 @@ help: add `struct` here to parse `S` as a public struct
 LL | pub struct S();
    |     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-struct-4.stderr b/tests/ui/pub/pub-ident-struct-4.stderr
index 90c7138e5ce..470874e0637 100644
--- a/tests/ui/pub/pub-ident-struct-4.stderr
+++ b/tests/ui/pub/pub-ident-struct-4.stderr
@@ -9,5 +9,5 @@ help: add `struct` here to parse `T` as a public struct
 LL | pub struct T(String);
    |     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-struct-with-lifetime.stderr b/tests/ui/pub/pub-ident-struct-with-lifetime.stderr
index 562b68e3542..0e08a5ff449 100644
--- a/tests/ui/pub/pub-ident-struct-with-lifetime.stderr
+++ b/tests/ui/pub/pub-ident-struct-with-lifetime.stderr
@@ -9,5 +9,5 @@ help: add `struct` here to parse `S` as a public struct
 LL | pub struct S<'a> {
    |     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-struct.stderr b/tests/ui/pub/pub-ident-struct.stderr
index d3a378786e4..2d5d61d9381 100644
--- a/tests/ui/pub/pub-ident-struct.stderr
+++ b/tests/ui/pub/pub-ident-struct.stderr
@@ -9,5 +9,5 @@ help: add `struct` here to parse `S` as a public struct
 LL | pub struct S {
    |     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-ident-with-lifetime-incomplete.stderr b/tests/ui/pub/pub-ident-with-lifetime-incomplete.stderr
index 0e0b127054d..750e2d17e0a 100644
--- a/tests/ui/pub/pub-ident-with-lifetime-incomplete.stderr
+++ b/tests/ui/pub/pub-ident-with-lifetime-incomplete.stderr
@@ -4,5 +4,5 @@ error: missing `fn` or `struct` for function or struct definition
 LL | pub   foo<'a>
    |    ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-restricted-error.stderr b/tests/ui/pub/pub-restricted-error.stderr
index b47328f34e6..4db84878317 100644
--- a/tests/ui/pub/pub-restricted-error.stderr
+++ b/tests/ui/pub/pub-restricted-error.stderr
@@ -6,5 +6,5 @@ LL | struct Foo {
 LL |     pub(crate) () foo: usize,
    |                ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/pub/pub-restricted-non-path.stderr b/tests/ui/pub/pub-restricted-non-path.stderr
index e0ea50621f7..1402ec231cd 100644
--- a/tests/ui/pub/pub-restricted-non-path.stderr
+++ b/tests/ui/pub/pub-restricted-non-path.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `.`
 LL | pub (.) fn afn() {}
    |      ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/qualified/qualified-path-params-2.stderr b/tests/ui/qualified/qualified-path-params-2.stderr
index b6cf19b8286..56644bdd46a 100644
--- a/tests/ui/qualified/qualified-path-params-2.stderr
+++ b/tests/ui/qualified/qualified-path-params-2.stderr
@@ -9,6 +9,6 @@ help: if there were a trait named `Example` with associated type `f` implemented
 LL | type A = <<S as Tr>::A as Example>::f;
    |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/query-system/fn-sig-cycle-arity.stderr b/tests/ui/query-system/fn-sig-cycle-arity.stderr
index 67e0c254551..fa1d033754e 100644
--- a/tests/ui/query-system/fn-sig-cycle-arity.stderr
+++ b/tests/ui/query-system/fn-sig-cycle-arity.stderr
@@ -4,6 +4,6 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL |     fn dance(&self) -> _ {
    |                        ^ not allowed in type signatures
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/query-system/no-query-in-printing-during-query-descr.stderr b/tests/ui/query-system/no-query-in-printing-during-query-descr.stderr
index 35e608b6b23..e86e38225a3 100644
--- a/tests/ui/query-system/no-query-in-printing-during-query-descr.stderr
+++ b/tests/ui/query-system/no-query-in-printing-during-query-descr.stderr
@@ -4,6 +4,6 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL | fn a() -> _ {
    |           ^ not allowed in type signatures
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/query-system/query_depth.stderr b/tests/ui/query-system/query_depth.stderr
index 43a18b4e074..d455e0e4ff8 100644
--- a/tests/ui/query-system/query_depth.stderr
+++ b/tests/ui/query-system/query_depth.stderr
@@ -7,5 +7,5 @@ LL | fn main() {
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "128"]` attribute to your crate (`query_depth`)
    = note: query depth increased by 66 when computing layout of `core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<core::option::Option<alloc::boxed::Box<alloc::string::String>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/range/range-inclusive-pattern-precedence.stderr b/tests/ui/range/range-inclusive-pattern-precedence.stderr
index f6788d034e6..2e2d7983c03 100644
--- a/tests/ui/range/range-inclusive-pattern-precedence.stderr
+++ b/tests/ui/range/range-inclusive-pattern-precedence.stderr
@@ -18,5 +18,5 @@ note: the lint level is defined here
 LL | #![warn(ellipsis_inclusive_range_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/range/range-inclusive-pattern-precedence2.stderr b/tests/ui/range/range-inclusive-pattern-precedence2.stderr
index bb4e3a13a5c..84294604c80 100644
--- a/tests/ui/range/range-inclusive-pattern-precedence2.stderr
+++ b/tests/ui/range/range-inclusive-pattern-precedence2.stderr
@@ -18,5 +18,5 @@ note: the lint level is defined here
 LL | #![warn(ellipsis_inclusive_range_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/range/range_traits-2.stderr b/tests/ui/range/range_traits-2.stderr
index 0829fc2ce9b..04778eecf56 100644
--- a/tests/ui/range/range_traits-2.stderr
+++ b/tests/ui/range/range_traits-2.stderr
@@ -8,6 +8,6 @@ LL | struct R(Range<usize>);
    |
    = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/range/range_traits-3.stderr b/tests/ui/range/range_traits-3.stderr
index db19d1baec9..094cc146b6c 100644
--- a/tests/ui/range/range_traits-3.stderr
+++ b/tests/ui/range/range_traits-3.stderr
@@ -8,6 +8,6 @@ LL | struct R(RangeFrom<usize>);
    |
    = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/range/range_traits-6.stderr b/tests/ui/range/range_traits-6.stderr
index dfc74f87ca7..7c66d1c749c 100644
--- a/tests/ui/range/range_traits-6.stderr
+++ b/tests/ui/range/range_traits-6.stderr
@@ -8,6 +8,6 @@ LL | struct R(RangeInclusive<usize>);
    |
    = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/reachable/expr_add.stderr b/tests/ui/reachable/expr_add.stderr
index 692bd20f509..f4a56fcbcb2 100644
--- a/tests/ui/reachable/expr_add.stderr
+++ b/tests/ui/reachable/expr_add.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/expr_again.stderr b/tests/ui/reachable/expr_again.stderr
index a3c54e13560..5dec512ba5d 100644
--- a/tests/ui/reachable/expr_again.stderr
+++ b/tests/ui/reachable/expr_again.stderr
@@ -13,5 +13,5 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/expr_repeat.stderr b/tests/ui/reachable/expr_repeat.stderr
index defa8704610..1949af2a9a0 100644
--- a/tests/ui/reachable/expr_repeat.stderr
+++ b/tests/ui/reachable/expr_repeat.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/expr_return.stderr b/tests/ui/reachable/expr_return.stderr
index 3791559f440..c9766f14d2c 100644
--- a/tests/ui/reachable/expr_return.stderr
+++ b/tests/ui/reachable/expr_return.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/expr_return_in_macro.stderr b/tests/ui/reachable/expr_return_in_macro.stderr
index 3c562a7ee6f..68ba6529a1d 100644
--- a/tests/ui/reachable/expr_return_in_macro.stderr
+++ b/tests/ui/reachable/expr_return_in_macro.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/expr_type.stderr b/tests/ui/reachable/expr_type.stderr
index 3cb4a32e02f..70536326fd8 100644
--- a/tests/ui/reachable/expr_type.stderr
+++ b/tests/ui/reachable/expr_type.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/unreachable-arm.stderr b/tests/ui/reachable/unreachable-arm.stderr
index 1cbea8288d4..60db8217640 100644
--- a/tests/ui/reachable/unreachable-arm.stderr
+++ b/tests/ui/reachable/unreachable-arm.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/unreachable-code-ret.stderr b/tests/ui/reachable/unreachable-code-ret.stderr
index 263a1b5a960..824515a2271 100644
--- a/tests/ui/reachable/unreachable-code-ret.stderr
+++ b/tests/ui/reachable/unreachable-code-ret.stderr
@@ -13,5 +13,5 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/unreachable-code.stderr b/tests/ui/reachable/unreachable-code.stderr
index cb1b760c282..52be0277c00 100644
--- a/tests/ui/reachable/unreachable-code.stderr
+++ b/tests/ui/reachable/unreachable-code.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/unreachable-loop-patterns.stderr b/tests/ui/reachable/unreachable-loop-patterns.stderr
index 80ffa5d73f0..1dea9d813f9 100644
--- a/tests/ui/reachable/unreachable-loop-patterns.stderr
+++ b/tests/ui/reachable/unreachable-loop-patterns.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/reachable/unreachable-variant.stderr b/tests/ui/reachable/unreachable-variant.stderr
index ca1d2be65ce..81faa59a07b 100644
--- a/tests/ui/reachable/unreachable-variant.stderr
+++ b/tests/ui/reachable/unreachable-variant.stderr
@@ -10,6 +10,6 @@ note: the module `super_sekrit` is defined here
 LL | mod super_sekrit {
    | ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/recursion/issue-26548-recursion-via-normalize.stderr b/tests/ui/recursion/issue-26548-recursion-via-normalize.stderr
index 514bed60700..e77fb025bcf 100644
--- a/tests/ui/recursion/issue-26548-recursion-via-normalize.stderr
+++ b/tests/ui/recursion/issue-26548-recursion-via-normalize.stderr
@@ -6,6 +6,6 @@ error[E0391]: cycle detected when computing layout of `core::option::Option<S>`
    = note: cycle used when computing layout of `core::option::Option<<S as Mirror>::It>`
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.stderr b/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.stderr
index 002dfe115b0..a5bbc5499a8 100644
--- a/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.stderr
+++ b/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.stderr
@@ -6,6 +6,6 @@ LL | fn f(x: S<u32>) {}
    |
    = note: overflowed on S<fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(fn(u32)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0320`.
diff --git a/tests/ui/recursion/issue-83150.stderr b/tests/ui/recursion/issue-83150.stderr
index 5df8af484a9..783f9cf7632 100644
--- a/tests/ui/recursion/issue-83150.stderr
+++ b/tests/ui/recursion/issue-83150.stderr
@@ -16,6 +16,6 @@ error[E0275]: overflow evaluating the requirement `Map<&mut std::ops::Range<u8>,
    = note: 65 redundant requirements hidden
    = note: required for `&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut Map<&mut std::ops::Range<u8>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>, {closure@$DIR/issue-83150.rs:13:24: 13:27}>` to implement `Iterator`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/recursion/recursion.stderr b/tests/ui/recursion/recursion.stderr
index cf08095372b..7a9f04d4bd6 100644
--- a/tests/ui/recursion/recursion.stderr
+++ b/tests/ui/recursion/recursion.stderr
@@ -11,5 +11,5 @@ LL | fn test<T:Dot> (n:isize, i:isize, first:T, second:T) ->isize {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/recursion/recursion/recursion.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion/recursive-enum.stderr b/tests/ui/recursion/recursive-enum.stderr
index d662d102203..b584cb46696 100644
--- a/tests/ui/recursion/recursive-enum.stderr
+++ b/tests/ui/recursion/recursive-enum.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | enum List<T> { Cons(T, Box<List<T>>), Nil }
    |                        ++++       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/recursion/recursive-reexports.stderr b/tests/ui/recursion/recursive-reexports.stderr
index f39d0a0d5e6..71653d26a18 100644
--- a/tests/ui/recursion/recursive-reexports.stderr
+++ b/tests/ui/recursion/recursive-reexports.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `S` in crate `recursive_reexports`
 LL | fn f() -> recursive_reexports::S {}
    |                                ^ not found in `recursive_reexports`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/recursion/recursive-static-definition.stderr b/tests/ui/recursion/recursive-static-definition.stderr
index b112228d403..570d203d07f 100644
--- a/tests/ui/recursion/recursive-static-definition.stderr
+++ b/tests/ui/recursion/recursive-static-definition.stderr
@@ -20,6 +20,6 @@ LL | | fn main() {}
    | |____________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/recursion/recursive-types-are-not-uninhabited.stderr b/tests/ui/recursion/recursive-types-are-not-uninhabited.stderr
index 1b4d80d9057..5abec88eeff 100644
--- a/tests/ui/recursion/recursive-types-are-not-uninhabited.stderr
+++ b/tests/ui/recursion/recursive-types-are-not-uninhabited.stderr
@@ -12,6 +12,6 @@ help: you might want to use `let else` to handle the variant that isn't matched
 LL |     let Ok(x) = res else { todo!() };
    |                     ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/recursion_limit/invalid_digit_type.stderr b/tests/ui/recursion_limit/invalid_digit_type.stderr
index 6d1409bb390..94442b5747f 100644
--- a/tests/ui/recursion_limit/invalid_digit_type.stderr
+++ b/tests/ui/recursion_limit/invalid_digit_type.stderr
@@ -4,5 +4,5 @@ error: malformed `recursion_limit` attribute input
 LL | #![recursion_limit = 123]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![recursion_limit = "N"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/invalid_macro.stderr b/tests/ui/recursion_limit/invalid_macro.stderr
index 0189e99da37..aa4894ec4d8 100644
--- a/tests/ui/recursion_limit/invalid_macro.stderr
+++ b/tests/ui/recursion_limit/invalid_macro.stderr
@@ -4,5 +4,5 @@ error: malformed `recursion_limit` attribute input
 LL | #![recursion_limit = foo!()]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![recursion_limit = "N"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/issue-105700.stderr b/tests/ui/recursion_limit/issue-105700.stderr
index 9b1114e9ce6..fd53d248c4e 100644
--- a/tests/ui/recursion_limit/issue-105700.stderr
+++ b/tests/ui/recursion_limit/issue-105700.stderr
@@ -6,5 +6,5 @@ LL | #![invalid_attribute]
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "8"]` attribute to your crate (`issue_105700`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/no-value.stderr b/tests/ui/recursion_limit/no-value.stderr
index 35ac2c4cd17..b2e8c46c372 100644
--- a/tests/ui/recursion_limit/no-value.stderr
+++ b/tests/ui/recursion_limit/no-value.stderr
@@ -4,5 +4,5 @@ error: malformed `recursion_limit` attribute input
 LL | #![recursion_limit]
    | ^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![recursion_limit = "N"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/zero-overflow.stderr b/tests/ui/recursion_limit/zero-overflow.stderr
index 9007ec0d784..fc03cc5b604 100644
--- a/tests/ui/recursion_limit/zero-overflow.stderr
+++ b/tests/ui/recursion_limit/zero-overflow.stderr
@@ -2,6 +2,6 @@ error[E0275]: overflow evaluating the requirement `&mut Self: DispatchFromDyn<&m
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "2"]` attribute to your crate (`zero_overflow`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/recursion_limit/zero.stderr b/tests/ui/recursion_limit/zero.stderr
index b43565909a3..f97eff19338 100644
--- a/tests/ui/recursion_limit/zero.stderr
+++ b/tests/ui/recursion_limit/zero.stderr
@@ -6,5 +6,5 @@ LL | test!(test);
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "2"]` attribute to your crate (`zero`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/do-not-suggest-adding-bound-to-opaque-type.stderr b/tests/ui/regions/do-not-suggest-adding-bound-to-opaque-type.stderr
index d76a83b0258..509863eaf88 100644
--- a/tests/ui/regions/do-not-suggest-adding-bound-to-opaque-type.stderr
+++ b/tests/ui/regions/do-not-suggest-adding-bound-to-opaque-type.stderr
@@ -11,6 +11,6 @@ LL |     S(&x)
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/regions/forall-wf-ref-reflexive.stderr b/tests/ui/regions/forall-wf-ref-reflexive.stderr
index 3d059ccec72..5ee7cc7866c 100644
--- a/tests/ui/regions/forall-wf-ref-reflexive.stderr
+++ b/tests/ui/regions/forall-wf-ref-reflexive.stderr
@@ -4,5 +4,5 @@ error: `T` does not live long enough
 LL |     self_wf2::<T>();
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/issue-101280.stderr b/tests/ui/regions/issue-101280.stderr
index 320d008aeff..70953808b81 100644
--- a/tests/ui/regions/issue-101280.stderr
+++ b/tests/ui/regions/issue-101280.stderr
@@ -9,6 +9,6 @@ LL |     f
    = note: expected fn pointer `for<'r> fn(Cell<(&'r i32, &'r i32)>)`
               found fn pointer `for<'a> fn(Cell<(&'r i32, &'a i32)>)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/issue-102374.stderr b/tests/ui/regions/issue-102374.stderr
index a4230cf8b5a..e07dca0c7ee 100644
--- a/tests/ui/regions/issue-102374.stderr
+++ b/tests/ui/regions/issue-102374.stderr
@@ -9,6 +9,6 @@ LL |     f
    = note:    expected type `i32`
            found fn pointer `for<'z1, 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, 'p, 'q, 'r, 's, 't, 'u, 'v, 'w, 'x, 'y, 'z, 'z0> fn(Cell<(&'z1 i32, &'a i32, &'b i32, &'c i32, &'d i32, &'e i32, &'f i32, &'g i32, &'h i32, &'i i32, &'j i32, &'k i32, &'l i32, &'m i32, &'n i32, &'o i32, &'p i32, &'q i32, &'r i32, &'s i32, &'t i32, &'u i32, &'v i32, &'w i32, &'x i32, &'y i32, &'z i32, &'z0 i32)>)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/issue-102392.stderr b/tests/ui/regions/issue-102392.stderr
index 56f4c0c5db4..fb3373091c2 100644
--- a/tests/ui/regions/issue-102392.stderr
+++ b/tests/ui/regions/issue-102392.stderr
@@ -9,6 +9,6 @@ LL |     f
    = note:    expected type `bool`
            found fn pointer `for<'a> fn(for<'b> fn(&'b str, &'a str))`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/issue-12470.stderr b/tests/ui/regions/issue-12470.stderr
index c97e59195ed..e6e629321e5 100644
--- a/tests/ui/regions/issue-12470.stderr
+++ b/tests/ui/regions/issue-12470.stderr
@@ -6,6 +6,6 @@ LL |     let bb: &B = &*b;
 LL |     make_a(bb)
    |     ^^^^^^^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/issue-28848.stderr b/tests/ui/regions/issue-28848.stderr
index a29dac4c9c8..0582295832f 100644
--- a/tests/ui/regions/issue-28848.stderr
+++ b/tests/ui/regions/issue-28848.stderr
@@ -10,5 +10,5 @@ LL |     Foo::<'a, 'b>::xmute(u)
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/issue-78262.base.stderr b/tests/ui/regions/issue-78262.base.stderr
index 7f232e4a7b2..113c84c6562 100644
--- a/tests/ui/regions/issue-78262.base.stderr
+++ b/tests/ui/regions/issue-78262.base.stderr
@@ -9,6 +9,6 @@ LL |     let f = |x: &dyn TT| x.func();
    |              |  let's call the lifetime of this reference `'1`
    |              `x` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/regions/issue-78262.polonius.stderr b/tests/ui/regions/issue-78262.polonius.stderr
index 7f232e4a7b2..113c84c6562 100644
--- a/tests/ui/regions/issue-78262.polonius.stderr
+++ b/tests/ui/regions/issue-78262.polonius.stderr
@@ -9,6 +9,6 @@ LL |     let f = |x: &dyn TT| x.func();
    |              |  let's call the lifetime of this reference `'1`
    |              `x` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/regions/outlives-with-missing.stderr b/tests/ui/regions/outlives-with-missing.stderr
index e204c918724..0e3aaaf5fdb 100644
--- a/tests/ui/regions/outlives-with-missing.stderr
+++ b/tests/ui/regions/outlives-with-missing.stderr
@@ -7,6 +7,6 @@ LL | impl<H: HandlerFamily> HandlerWrapper<H> {
 LL |         T: Send + Sync + 'static,
    |         ^ help: a type parameter with a similar name exists: `H`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/regions/region-bound-on-closure-outlives-call.stderr b/tests/ui/regions/region-bound-on-closure-outlives-call.stderr
index ea43dde11f8..96d0cb80a74 100644
--- a/tests/ui/regions/region-bound-on-closure-outlives-call.stderr
+++ b/tests/ui/regions/region-bound-on-closure-outlives-call.stderr
@@ -19,6 +19,6 @@ LL |     (|x| f(x))(call_rec(f))
    |      |   borrow occurs due to use in closure
    |      borrow of `f` occurs here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/regions/region-invariant-static-error-reporting.stderr b/tests/ui/regions/region-invariant-static-error-reporting.stderr
index 2ad39b00071..834d5c6cf5a 100644
--- a/tests/ui/regions/region-invariant-static-error-reporting.stderr
+++ b/tests/ui/regions/region-invariant-static-error-reporting.stderr
@@ -16,6 +16,6 @@ LL |         x.unwrap()
    = note: the struct `Invariant<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/regions/region-lifetime-bounds-on-fns-where-clause.stderr b/tests/ui/regions/region-lifetime-bounds-on-fns-where-clause.stderr
index a9a92b7a695..03d5a0be723 100644
--- a/tests/ui/regions/region-lifetime-bounds-on-fns-where-clause.stderr
+++ b/tests/ui/regions/region-lifetime-bounds-on-fns-where-clause.stderr
@@ -9,6 +9,6 @@ LL |     let _: fn(&mut &isize, &mut &isize) = a;
    = note: expected fn pointer `for<'a, 'b, 'c, 'd> fn(&'a mut &'b isize, &'c mut &'d isize)`
                  found fn item `for<'a, 'b> fn(&'a mut &isize, &'b mut &isize) {a::<'_, '_>}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/region-multiple-lifetime-bounds-on-fns-where-clause.stderr b/tests/ui/regions/region-multiple-lifetime-bounds-on-fns-where-clause.stderr
index e96559937d4..250571f1556 100644
--- a/tests/ui/regions/region-multiple-lifetime-bounds-on-fns-where-clause.stderr
+++ b/tests/ui/regions/region-multiple-lifetime-bounds-on-fns-where-clause.stderr
@@ -9,6 +9,6 @@ LL |     let _: fn(&mut &isize, &mut &isize, &mut &isize) = a;
    = note: expected fn pointer `for<'a, 'b, 'c, 'd, 'e, 'f> fn(&'a mut &'b isize, &'c mut &'d isize, &'e mut &'f isize)`
                  found fn item `for<'a, 'b, 'c> fn(&'a mut &isize, &'b mut &isize, &'c mut &isize) {a::<'_, '_, '_>}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/region-object-lifetime-2.stderr b/tests/ui/regions/region-object-lifetime-2.stderr
index d95289f3f9d..7eb5d39ecfa 100644
--- a/tests/ui/regions/region-object-lifetime-2.stderr
+++ b/tests/ui/regions/region-object-lifetime-2.stderr
@@ -10,5 +10,5 @@ LL |     x.borrowed()
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/region-object-lifetime-4.stderr b/tests/ui/regions/region-object-lifetime-4.stderr
index fda66a2412c..713252dbc08 100644
--- a/tests/ui/regions/region-object-lifetime-4.stderr
+++ b/tests/ui/regions/region-object-lifetime-4.stderr
@@ -10,5 +10,5 @@ LL |     x.borrowed()
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/region-object-lifetime-5.stderr b/tests/ui/regions/region-object-lifetime-5.stderr
index b86f6e3a2a1..e8960fcc656 100644
--- a/tests/ui/regions/region-object-lifetime-5.stderr
+++ b/tests/ui/regions/region-object-lifetime-5.stderr
@@ -7,6 +7,6 @@ LL |     x.borrowed()
    |     returns a value referencing data owned by the current function
    |     `*x` is borrowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-addr-of-self.stderr b/tests/ui/regions/regions-addr-of-self.stderr
index 3d7aac74bd4..75e1abdda20 100644
--- a/tests/ui/regions/regions-addr-of-self.stderr
+++ b/tests/ui/regions/regions-addr-of-self.stderr
@@ -6,5 +6,5 @@ LL |     pub fn chase_cat(&mut self) {
 LL |         let p: &'static mut usize = &mut self.cats_chased;
    |                ^^^^^^^^^^^^^^^^^^ type annotation requires that `'1` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.stderr b/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.stderr
index 2a262520361..2a5831aad25 100644
--- a/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.stderr
+++ b/tests/ui/regions/regions-assoc-type-in-supertrait-outlives-container.stderr
@@ -11,5 +11,5 @@ LL |     let _: &'a WithAssoc<TheType<'b>> = loop { };
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-assoc-type-static-bound-in-trait-not-met.stderr b/tests/ui/regions/regions-assoc-type-static-bound-in-trait-not-met.stderr
index a96f5612fa2..6ffe416ca5f 100644
--- a/tests/ui/regions/regions-assoc-type-static-bound-in-trait-not-met.stderr
+++ b/tests/ui/regions/regions-assoc-type-static-bound-in-trait-not-met.stderr
@@ -10,6 +10,6 @@ note: type must satisfy the static lifetime as required by this binding
 LL |     type Value: 'static;
    |                 ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0477`.
diff --git a/tests/ui/regions/regions-bounded-method-type-parameters-cross-crate.stderr b/tests/ui/regions/regions-bounded-method-type-parameters-cross-crate.stderr
index 6193bf02f6d..bd8640b9d34 100644
--- a/tests/ui/regions/regions-bounded-method-type-parameters-cross-crate.stderr
+++ b/tests/ui/regions/regions-bounded-method-type-parameters-cross-crate.stderr
@@ -14,5 +14,5 @@ LL |     a.bigger_region(b)
    = note: the struct `Inv<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-bounded-method-type-parameters-trait-bound.stderr b/tests/ui/regions/regions-bounded-method-type-parameters-trait-bound.stderr
index 0e0086be9ea..df37df99bf2 100644
--- a/tests/ui/regions/regions-bounded-method-type-parameters-trait-bound.stderr
+++ b/tests/ui/regions/regions-bounded-method-type-parameters-trait-bound.stderr
@@ -14,5 +14,5 @@ LL |     f.method(b);
    = note: the struct `Inv<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-bounded-method-type-parameters.stderr b/tests/ui/regions/regions-bounded-method-type-parameters.stderr
index b6d7b8aac5f..f1375404443 100644
--- a/tests/ui/regions/regions-bounded-method-type-parameters.stderr
+++ b/tests/ui/regions/regions-bounded-method-type-parameters.stderr
@@ -6,5 +6,5 @@ LL | fn caller<'a>(x: &isize) {
 LL |     Foo.some_method::<&'a isize>();
    |         ^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-close-object-into-object-1.stderr b/tests/ui/regions/regions-close-object-into-object-1.stderr
index 5bfaeb295c3..8353587c646 100644
--- a/tests/ui/regions/regions-close-object-into-object-1.stderr
+++ b/tests/ui/regions/regions-close-object-into-object-1.stderr
@@ -7,6 +7,6 @@ LL |     Box::new(B(&*v)) as Box<X>
    |     |          `*v` is borrowed here
    |     returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-close-object-into-object-3.stderr b/tests/ui/regions/regions-close-object-into-object-3.stderr
index 9f92c40e1e1..706595ae87f 100644
--- a/tests/ui/regions/regions-close-object-into-object-3.stderr
+++ b/tests/ui/regions/regions-close-object-into-object-3.stderr
@@ -7,6 +7,6 @@ LL |     Box::new(B(&*v)) as Box<X>
    |     |          `*v` is borrowed here
    |     returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-close-over-type-parameter-multiple.stderr b/tests/ui/regions/regions-close-over-type-parameter-multiple.stderr
index baa0506d04c..a353ff89b80 100644
--- a/tests/ui/regions/regions-close-over-type-parameter-multiple.stderr
+++ b/tests/ui/regions/regions-close-over-type-parameter-multiple.stderr
@@ -11,5 +11,5 @@ LL |     Box::new(v) as Box<dyn SomeTrait + 'a>
    |
    = help: consider adding the following bound: `'a: 'c`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-creating-enums3.stderr b/tests/ui/regions/regions-creating-enums3.stderr
index 41d609b56d2..93a0a1dc7c2 100644
--- a/tests/ui/regions/regions-creating-enums3.stderr
+++ b/tests/ui/regions/regions-creating-enums3.stderr
@@ -10,5 +10,5 @@ LL |     Ast::Add(x, y)
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-creating-enums4.stderr b/tests/ui/regions/regions-creating-enums4.stderr
index 91cf57e099d..fee2b77795a 100644
--- a/tests/ui/regions/regions-creating-enums4.stderr
+++ b/tests/ui/regions/regions-creating-enums4.stderr
@@ -10,5 +10,5 @@ LL |     Ast::Add(x, y)
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-early-bound-error-method.stderr b/tests/ui/regions/regions-early-bound-error-method.stderr
index a7746d8981e..8c79eb222be 100644
--- a/tests/ui/regions/regions-early-bound-error-method.stderr
+++ b/tests/ui/regions/regions-early-bound-error-method.stderr
@@ -10,5 +10,5 @@ LL |         g2.get()
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-early-bound-error.stderr b/tests/ui/regions/regions-early-bound-error.stderr
index eb4cd5ca72e..5ad16069ab9 100644
--- a/tests/ui/regions/regions-early-bound-error.stderr
+++ b/tests/ui/regions/regions-early-bound-error.stderr
@@ -10,5 +10,5 @@ LL |     g1.get()
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-escape-method.stderr b/tests/ui/regions/regions-escape-method.stderr
index 9f425125b98..aeda923b0ba 100644
--- a/tests/ui/regions/regions-escape-method.stderr
+++ b/tests/ui/regions/regions-escape-method.stderr
@@ -7,5 +7,5 @@ LL |     s.f(|p| p)
    |          |return type of closure is &'2 i32
    |          has type `&'1 i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-escape-via-trait-or-not.stderr b/tests/ui/regions/regions-escape-via-trait-or-not.stderr
index cae6c33ac6e..4d185e52d01 100644
--- a/tests/ui/regions/regions-escape-via-trait-or-not.stderr
+++ b/tests/ui/regions/regions-escape-via-trait-or-not.stderr
@@ -7,5 +7,5 @@ LL |     with(|o| o)
    |           |return type of closure is &'2 isize
    |           has type `&'1 isize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-fn-subtyping-return-static-fail.stderr b/tests/ui/regions/regions-fn-subtyping-return-static-fail.stderr
index 8d82ff958ff..2ccdd65f295 100644
--- a/tests/ui/regions/regions-fn-subtyping-return-static-fail.stderr
+++ b/tests/ui/regions/regions-fn-subtyping-return-static-fail.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn want_G(f: G) {}
    |    ^^^^^^ ----
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/regions-free-region-ordering-callee-4.stderr b/tests/ui/regions/regions-free-region-ordering-callee-4.stderr
index 1df7ca0e3e9..1c8f1c1e472 100644
--- a/tests/ui/regions/regions-free-region-ordering-callee-4.stderr
+++ b/tests/ui/regions/regions-free-region-ordering-callee-4.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL | fn ordering4<'a, 'b, F>(a: &'a usize, b: &'b usize, x: F) where F: FnOnce(&'a &'b usize) {
    |                  ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/regions/regions-free-region-ordering-incorrect.stderr b/tests/ui/regions/regions-free-region-ordering-incorrect.stderr
index d0ceaec3b67..9025f0c3cbd 100644
--- a/tests/ui/regions/regions-free-region-ordering-incorrect.stderr
+++ b/tests/ui/regions/regions-free-region-ordering-incorrect.stderr
@@ -13,5 +13,5 @@ LL | |         }
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-glb-free-free.stderr b/tests/ui/regions/regions-glb-free-free.stderr
index 575037a0a4d..727669f2683 100644
--- a/tests/ui/regions/regions-glb-free-free.stderr
+++ b/tests/ui/regions/regions-glb-free-free.stderr
@@ -11,6 +11,6 @@ LL | |                 value: self.value
 LL | |             }
    | |_____________^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr b/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
index 8c1791fc11d..7d9f9121a48 100644
--- a/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
+++ b/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn func<'x, T:Trait1<'x> + 'x>(t: &'x T::Foo)
    |                          ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr b/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
index 6844e866532..1555e5981c5 100644
--- a/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
+++ b/tests/ui/regions/regions-implied-bounds-projection-gap-hr-1.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | fn callee<'x, 'y, T: for<'z> Trait2<'y, 'z>>(t: &'x dyn for<'z> Trait1< <T as Trait2<'y, 'z>>::Foo >)
    |                    ++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/regions/regions-in-enums-anon.stderr b/tests/ui/regions/regions-in-enums-anon.stderr
index ed547aa9c41..86a6d33d6d3 100644
--- a/tests/ui/regions/regions-in-enums-anon.stderr
+++ b/tests/ui/regions/regions-in-enums-anon.stderr
@@ -10,6 +10,6 @@ LL ~ enum Foo<'a> {
 LL ~     Bar(&'a isize)
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/regions/regions-in-structs-anon.stderr b/tests/ui/regions/regions-in-structs-anon.stderr
index 992d25c9fd1..2679ef93b97 100644
--- a/tests/ui/regions/regions-in-structs-anon.stderr
+++ b/tests/ui/regions/regions-in-structs-anon.stderr
@@ -10,6 +10,6 @@ LL ~ struct Foo<'a> {
 LL ~     x: &'a isize
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/regions/regions-infer-at-fn-not-param.stderr b/tests/ui/regions/regions-infer-at-fn-not-param.stderr
index 8cfc44f6abd..4c7660276f2 100644
--- a/tests/ui/regions/regions-infer-at-fn-not-param.stderr
+++ b/tests/ui/regions/regions-infer-at-fn-not-param.stderr
@@ -6,6 +6,6 @@ LL | fn take1<'a>(p: Parameterized1) -> Parameterized1<'a> { p }
    |                 |
    |                 help: add explicit lifetime `'a` to the type of `p`: `Parameterized1<'a>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/regions/regions-infer-borrow-scope-too-big.stderr b/tests/ui/regions/regions-infer-borrow-scope-too-big.stderr
index 2c7a6e8b5c0..15dc1cef83c 100644
--- a/tests/ui/regions/regions-infer-borrow-scope-too-big.stderr
+++ b/tests/ui/regions/regions-infer-borrow-scope-too-big.stderr
@@ -7,6 +7,6 @@ LL |     assert_eq!(*xc, 3);
 LL |     return xc;
    |            ^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-infer-bound-from-trait-self.stderr b/tests/ui/regions/regions-infer-bound-from-trait-self.stderr
index d0c4b9a57e0..7bf112dc721 100644
--- a/tests/ui/regions/regions-infer-bound-from-trait-self.stderr
+++ b/tests/ui/regions/regions-infer-bound-from-trait-self.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | trait InheritsFromNothing<'a> : Sized where Self: 'a {
    |                                       ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/regions/regions-infer-call-3.stderr b/tests/ui/regions/regions-infer-call-3.stderr
index ca51555a077..14d1ce7ae8b 100644
--- a/tests/ui/regions/regions-infer-call-3.stderr
+++ b/tests/ui/regions/regions-infer-call-3.stderr
@@ -7,5 +7,5 @@ LL |     let z = with(|y| { select(x, y) });
    |                   |return type of closure is &'2 isize
    |                   has type `&'1 isize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-contravariance-due-to-decl.stderr b/tests/ui/regions/regions-infer-contravariance-due-to-decl.stderr
index 94b80852d01..56ee07bdebd 100644
--- a/tests/ui/regions/regions-infer-contravariance-due-to-decl.stderr
+++ b/tests/ui/regions/regions-infer-contravariance-due-to-decl.stderr
@@ -11,5 +11,5 @@ LL |     let _: Contravariant<'long> = c;
    |
    = help: consider adding the following bound: `'short: 'long`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-covariance-due-to-decl.stderr b/tests/ui/regions/regions-infer-covariance-due-to-decl.stderr
index f44a0fad59b..013475c2691 100644
--- a/tests/ui/regions/regions-infer-covariance-due-to-decl.stderr
+++ b/tests/ui/regions/regions-infer-covariance-due-to-decl.stderr
@@ -11,5 +11,5 @@ LL |     let _: Covariant<'short> = c;
    |
    = help: consider adding the following bound: `'short: 'long`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-invariance-due-to-decl.stderr b/tests/ui/regions/regions-infer-invariance-due-to-decl.stderr
index c8c7808e06c..2b17f74ad1b 100644
--- a/tests/ui/regions/regions-infer-invariance-due-to-decl.stderr
+++ b/tests/ui/regions/regions-infer-invariance-due-to-decl.stderr
@@ -10,5 +10,5 @@ LL |     b_isize
    = note: the struct `Invariant<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-invariance-due-to-mutability-3.stderr b/tests/ui/regions/regions-infer-invariance-due-to-mutability-3.stderr
index 1165011c1f4..9cb9dac4fdf 100644
--- a/tests/ui/regions/regions-infer-invariance-due-to-mutability-3.stderr
+++ b/tests/ui/regions/regions-infer-invariance-due-to-mutability-3.stderr
@@ -10,5 +10,5 @@ LL |     b_isize
    = note: the struct `Invariant<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-invariance-due-to-mutability-4.stderr b/tests/ui/regions/regions-infer-invariance-due-to-mutability-4.stderr
index f3973a93bad..098a9c11de4 100644
--- a/tests/ui/regions/regions-infer-invariance-due-to-mutability-4.stderr
+++ b/tests/ui/regions/regions-infer-invariance-due-to-mutability-4.stderr
@@ -10,5 +10,5 @@ LL |     b_isize
    = note: the struct `Invariant<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-paramd-indirect.stderr b/tests/ui/regions/regions-infer-paramd-indirect.stderr
index afabdc1de1c..4a1cd111936 100644
--- a/tests/ui/regions/regions-infer-paramd-indirect.stderr
+++ b/tests/ui/regions/regions-infer-paramd-indirect.stderr
@@ -9,5 +9,5 @@ LL |     fn set_f_bad(&mut self, b: Box<B>) {
 LL |         self.f = b;
    |         ^^^^^^ assignment requires that `'1` must outlive `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-infer-proc-static-upvar.stderr b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
index c8a33bbc522..919fcffdc53 100644
--- a/tests/ui/regions/regions-infer-proc-static-upvar.stderr
+++ b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
@@ -12,6 +12,6 @@ LL | |     });
 LL |   }
    |   - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/regions/regions-lifetime-bounds-on-fns.stderr b/tests/ui/regions/regions-lifetime-bounds-on-fns.stderr
index 53a5612d24f..31dd7efe067 100644
--- a/tests/ui/regions/regions-lifetime-bounds-on-fns.stderr
+++ b/tests/ui/regions/regions-lifetime-bounds-on-fns.stderr
@@ -9,6 +9,6 @@ LL |     let _: fn(&mut &isize, &mut &isize) = a;
    = note: expected fn pointer `for<'a, 'b, 'c, 'd> fn(&'a mut &'b isize, &'c mut &'d isize)`
                  found fn item `for<'a, 'b> fn(&'a mut &isize, &'b mut &isize) {a::<'_, '_>}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/regions/regions-name-duplicated.stderr b/tests/ui/regions/regions-name-duplicated.stderr
index cef73c18d37..8b0cc925a86 100644
--- a/tests/ui/regions/regions-name-duplicated.stderr
+++ b/tests/ui/regions/regions-name-duplicated.stderr
@@ -6,6 +6,6 @@ LL | struct Foo<'a, 'a> {
    |            |
    |            first use of `'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0403`.
diff --git a/tests/ui/regions/regions-name-static.stderr b/tests/ui/regions/regions-name-static.stderr
index 4b7026e65ea..6d334b498af 100644
--- a/tests/ui/regions/regions-name-static.stderr
+++ b/tests/ui/regions/regions-name-static.stderr
@@ -4,6 +4,6 @@ error[E0262]: invalid lifetime parameter name: `'static`
 LL | struct Foo<'static> {
    |            ^^^^^^^ 'static is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0262`.
diff --git a/tests/ui/regions/regions-nested-fns-2.stderr b/tests/ui/regions/regions-nested-fns-2.stderr
index 43c8d1272c7..254497639a1 100644
--- a/tests/ui/regions/regions-nested-fns-2.stderr
+++ b/tests/ui/regions/regions-nested-fns-2.stderr
@@ -12,6 +12,6 @@ LL |             if false { &y } else { z }
 LL | }
    | - `y` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/regions/regions-normalize-in-where-clause-list.stderr b/tests/ui/regions/regions-normalize-in-where-clause-list.stderr
index 5672837290c..2e76333e26f 100644
--- a/tests/ui/regions/regions-normalize-in-where-clause-list.stderr
+++ b/tests/ui/regions/regions-normalize-in-where-clause-list.stderr
@@ -22,6 +22,6 @@ LL | fn bar<'a, 'b>()
    = note: expected `Project<'a, 'b>`
               found `Project<'_, '_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0495`.
diff --git a/tests/ui/regions/regions-outlives-projection-container-wc.stderr b/tests/ui/regions/regions-outlives-projection-container-wc.stderr
index eba2a0d5853..1c270d6c366 100644
--- a/tests/ui/regions/regions-outlives-projection-container-wc.stderr
+++ b/tests/ui/regions/regions-outlives-projection-container-wc.stderr
@@ -11,5 +11,5 @@ LL |     let _: &'a WithAssoc<TheType<'b>> = loop { };
    |
    = help: consider adding the following bound: `'b: 'a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
index 18aec29ad0b..1d3d5e831c3 100644
--- a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
+++ b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
@@ -11,6 +11,6 @@ LL |     }
 LL | }
    | - `line` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/regions/regions-pattern-typing-issue-19997.stderr b/tests/ui/regions/regions-pattern-typing-issue-19997.stderr
index 0abe77a8697..b2f63b3b8f2 100644
--- a/tests/ui/regions/regions-pattern-typing-issue-19997.stderr
+++ b/tests/ui/regions/regions-pattern-typing-issue-19997.stderr
@@ -9,6 +9,6 @@ LL |             a1 = &f;
 LL |             drop(b0);
    |                  -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0506`.
diff --git a/tests/ui/regions/regions-proc-bound-capture.stderr b/tests/ui/regions/regions-proc-bound-capture.stderr
index 60c5246e240..3fe497bf2e9 100644
--- a/tests/ui/regions/regions-proc-bound-capture.stderr
+++ b/tests/ui/regions/regions-proc-bound-capture.stderr
@@ -16,5 +16,5 @@ help: alternatively, add an explicit `'static` bound to this reference
 LL | fn static_proc(x: &'static isize) -> Box<dyn FnMut() -> (isize) + 'static> {
    |                   ~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-reborrow-from-shorter-mut-ref-mut-ref.stderr b/tests/ui/regions/regions-reborrow-from-shorter-mut-ref-mut-ref.stderr
index dc905d076bb..40d4f165279 100644
--- a/tests/ui/regions/regions-reborrow-from-shorter-mut-ref-mut-ref.stderr
+++ b/tests/ui/regions/regions-reborrow-from-shorter-mut-ref-mut-ref.stderr
@@ -10,5 +10,5 @@ LL |     &mut ***p
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-reborrow-from-shorter-mut-ref.stderr b/tests/ui/regions/regions-reborrow-from-shorter-mut-ref.stderr
index c98ec477417..fd23fce76c8 100644
--- a/tests/ui/regions/regions-reborrow-from-shorter-mut-ref.stderr
+++ b/tests/ui/regions/regions-reborrow-from-shorter-mut-ref.stderr
@@ -10,5 +10,5 @@ LL |     &mut **p
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-ret-borrowed-1.stderr b/tests/ui/regions/regions-ret-borrowed-1.stderr
index 0784e894ea9..4ad526602df 100644
--- a/tests/ui/regions/regions-ret-borrowed-1.stderr
+++ b/tests/ui/regions/regions-ret-borrowed-1.stderr
@@ -7,5 +7,5 @@ LL |     with(|o| o)
    |           |return type of closure is &'2 isize
    |           has type `&'1 isize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-ret-borrowed.stderr b/tests/ui/regions/regions-ret-borrowed.stderr
index d9be5ef89cc..f16a4a2e8c1 100644
--- a/tests/ui/regions/regions-ret-borrowed.stderr
+++ b/tests/ui/regions/regions-ret-borrowed.stderr
@@ -7,5 +7,5 @@ LL |     with(|o| o)
    |           |return type of closure is &'2 isize
    |           has type `&'1 isize`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-ret.stderr b/tests/ui/regions/regions-ret.stderr
index 0e4875ac985..470b6ab06dd 100644
--- a/tests/ui/regions/regions-ret.stderr
+++ b/tests/ui/regions/regions-ret.stderr
@@ -7,6 +7,6 @@ LL |     return &id(3);
    |            |temporary value created here
    |            returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-return-ref-to-upvar-issue-17403.stderr b/tests/ui/regions/regions-return-ref-to-upvar-issue-17403.stderr
index b087e03b464..be9ffbe8d91 100644
--- a/tests/ui/regions/regions-return-ref-to-upvar-issue-17403.stderr
+++ b/tests/ui/regions/regions-return-ref-to-upvar-issue-17403.stderr
@@ -13,5 +13,5 @@ LL |         let mut f = || &mut x;
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-return-stack-allocated-vec.stderr b/tests/ui/regions/regions-return-stack-allocated-vec.stderr
index 9d87fe266b1..68631c74e77 100644
--- a/tests/ui/regions/regions-return-stack-allocated-vec.stderr
+++ b/tests/ui/regions/regions-return-stack-allocated-vec.stderr
@@ -7,6 +7,6 @@ LL |     &[x]
    |     |temporary value created here
    |     returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-steal-closure.stderr b/tests/ui/regions/regions-steal-closure.stderr
index 5b0efaf9559..9324eb892a6 100644
--- a/tests/ui/regions/regions-steal-closure.stderr
+++ b/tests/ui/regions/regions-steal-closure.stderr
@@ -11,6 +11,6 @@ LL |         box_it(Box::new(|| i += 1))
 LL |     };
    |     - `i` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/regions/regions-trait-variance.stderr b/tests/ui/regions/regions-trait-variance.stderr
index 56c9f89e1f5..235950c2e0a 100644
--- a/tests/ui/regions/regions-trait-variance.stderr
+++ b/tests/ui/regions/regions-trait-variance.stderr
@@ -6,6 +6,6 @@ LL |     let bb: &B = &*b;
 LL |     make_a(bb)
    |     ^^^^^^^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/regions/regions-var-type-out-of-scope.stderr b/tests/ui/regions/regions-var-type-out-of-scope.stderr
index c32bbe0ee1f..b261f5a41b6 100644
--- a/tests/ui/regions/regions-var-type-out-of-scope.stderr
+++ b/tests/ui/regions/regions-var-type-out-of-scope.stderr
@@ -10,6 +10,6 @@ LL |         assert_eq!(*x, 3);
    |
    = note: consider using a `let` binding to create a longer lived value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/regions/regions-variance-contravariant-use-covariant-in-second-position.stderr b/tests/ui/regions/regions-variance-contravariant-use-covariant-in-second-position.stderr
index 5352be430fb..5e952ee5771 100644
--- a/tests/ui/regions/regions-variance-contravariant-use-covariant-in-second-position.stderr
+++ b/tests/ui/regions/regions-variance-contravariant-use-covariant-in-second-position.stderr
@@ -11,5 +11,5 @@ LL |     let _: S<'long, 'long> = c;
    |
    = help: consider adding the following bound: `'short: 'long`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-variance-contravariant-use-covariant.stderr b/tests/ui/regions/regions-variance-contravariant-use-covariant.stderr
index 22c9b915bb9..bb96bf5970c 100644
--- a/tests/ui/regions/regions-variance-contravariant-use-covariant.stderr
+++ b/tests/ui/regions/regions-variance-contravariant-use-covariant.stderr
@@ -11,5 +11,5 @@ LL |     let _: Contravariant<'long> = c;
    |
    = help: consider adding the following bound: `'short: 'long`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-variance-covariant-use-contravariant.stderr b/tests/ui/regions/regions-variance-covariant-use-contravariant.stderr
index a07181ad553..b544bf5ecb2 100644
--- a/tests/ui/regions/regions-variance-covariant-use-contravariant.stderr
+++ b/tests/ui/regions/regions-variance-covariant-use-contravariant.stderr
@@ -11,5 +11,5 @@ LL |     let _: Covariant<'short> = c;
    |
    = help: consider adding the following bound: `'short: 'long`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-variance-invariant-use-contravariant.stderr b/tests/ui/regions/regions-variance-invariant-use-contravariant.stderr
index b35a2cb905d..4695045bbb7 100644
--- a/tests/ui/regions/regions-variance-invariant-use-contravariant.stderr
+++ b/tests/ui/regions/regions-variance-invariant-use-contravariant.stderr
@@ -14,5 +14,5 @@ LL |     let _: Invariant<'short> = c;
    = note: the struct `Invariant<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-variance-invariant-use-covariant.stderr b/tests/ui/regions/regions-variance-invariant-use-covariant.stderr
index 761e78d179e..5945f9ba1ba 100644
--- a/tests/ui/regions/regions-variance-invariant-use-covariant.stderr
+++ b/tests/ui/regions/regions-variance-invariant-use-covariant.stderr
@@ -11,5 +11,5 @@ LL |     let _: Invariant<'static> = c;
    = note: the struct `Invariant<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-wf-trait-object.stderr b/tests/ui/regions/regions-wf-trait-object.stderr
index f6006ca046a..20996150820 100644
--- a/tests/ui/regions/regions-wf-trait-object.stderr
+++ b/tests/ui/regions/regions-wf-trait-object.stderr
@@ -15,6 +15,6 @@ note: but lifetime parameter must outlive the lifetime `'a` as defined here
 LL | struct Foo<'a,'b> {
    |            ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0478`.
diff --git a/tests/ui/repeat-expr/repeat-to-run-dtor-twice.stderr b/tests/ui/repeat-expr/repeat-to-run-dtor-twice.stderr
index 1bf8e6e062f..2e3ede46eca 100644
--- a/tests/ui/repeat-expr/repeat-to-run-dtor-twice.stderr
+++ b/tests/ui/repeat-expr/repeat-to-run-dtor-twice.stderr
@@ -11,6 +11,6 @@ LL + #[derive(Copy)]
 LL | struct Foo {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/repr/repr-disallow-on-variant.stderr b/tests/ui/repr/repr-disallow-on-variant.stderr
index f7e4dcc9d81..ebdb851b7a6 100644
--- a/tests/ui/repr/repr-disallow-on-variant.stderr
+++ b/tests/ui/repr/repr-disallow-on-variant.stderr
@@ -7,6 +7,6 @@ LL |
 LL |     Variant,
    |     ------- not an enum
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0517`.
diff --git a/tests/ui/repr/transparent-enum-too-many-variants.stderr b/tests/ui/repr/transparent-enum-too-many-variants.stderr
index 1a500257f48..1e434d22b10 100644
--- a/tests/ui/repr/transparent-enum-too-many-variants.stderr
+++ b/tests/ui/repr/transparent-enum-too-many-variants.stderr
@@ -8,6 +8,6 @@ LL |     A(u8), B(u8),
    |     |
    |     variant here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0731`.
diff --git a/tests/ui/reserved/reserved-become.stderr b/tests/ui/reserved/reserved-become.stderr
index 0703b76d6de..8e9fa18557c 100644
--- a/tests/ui/reserved/reserved-become.stderr
+++ b/tests/ui/reserved/reserved-become.stderr
@@ -9,5 +9,5 @@ help: escape `become` to use it as an identifier
 LL |     let r#become = 0;
    |         ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/bad-type-env-capture.stderr b/tests/ui/resolve/bad-type-env-capture.stderr
index 941b6b7a68c..3f9bc9149c2 100644
--- a/tests/ui/resolve/bad-type-env-capture.stderr
+++ b/tests/ui/resolve/bad-type-env-capture.stderr
@@ -8,6 +8,6 @@ LL |     fn bar(b: T) { }
    |           |
    |           help: try introducing a local generic parameter here: `<T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/resolve/crate-called-as-function.stderr b/tests/ui/resolve/crate-called-as-function.stderr
index eb42349aff1..1d6eb8ad6f5 100644
--- a/tests/ui/resolve/crate-called-as-function.stderr
+++ b/tests/ui/resolve/crate-called-as-function.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find external crate `foo` in the crate root
 LL |     ::foo()
    |       ^^^ not found in the crate root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/crate-in-paths.stderr b/tests/ui/resolve/crate-in-paths.stderr
index 07fb5dcc035..9eb735a3aab 100644
--- a/tests/ui/resolve/crate-in-paths.stderr
+++ b/tests/ui/resolve/crate-in-paths.stderr
@@ -9,6 +9,6 @@ help: consider importing this unit struct
 LL + use crate::bar::Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/disambiguate-identical-names.stderr b/tests/ui/resolve/disambiguate-identical-names.stderr
index 7d8293018d2..9900ade3d8e 100644
--- a/tests/ui/resolve/disambiguate-identical-names.stderr
+++ b/tests/ui/resolve/disambiguate-identical-names.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn test(_v: &Vec<Vec<u32>>) {
    |    ^^^^ ------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/resolve/enums-pats-not-idents.stderr b/tests/ui/resolve/enums-pats-not-idents.stderr
index 072b88716ad..6bb6e152c80 100644
--- a/tests/ui/resolve/enums-pats-not-idents.stderr
+++ b/tests/ui/resolve/enums-pats-not-idents.stderr
@@ -4,6 +4,6 @@ error[E0531]: cannot find tuple struct or tuple variant `a` in this scope
 LL |     let a(1) = 13;
    |         ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0531`.
diff --git a/tests/ui/resolve/explicit-self-lowercase-param.stderr b/tests/ui/resolve/explicit-self-lowercase-param.stderr
index cd64dbb3854..6daa6f5d7af 100644
--- a/tests/ui/resolve/explicit-self-lowercase-param.stderr
+++ b/tests/ui/resolve/explicit-self-lowercase-param.stderr
@@ -4,5 +4,5 @@ error: attempt to use a non-constant value in a constant
 LL |     fn do_nothing(self: Box<self>) {}
    |                             ^^^^ help: try using `Self`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/export-fully-qualified-2018.stderr b/tests/ui/resolve/export-fully-qualified-2018.stderr
index b724da930df..378d9832a65 100644
--- a/tests/ui/resolve/export-fully-qualified-2018.stderr
+++ b/tests/ui/resolve/export-fully-qualified-2018.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `foo`
 LL |     pub fn bar() { foo::baz(); }
    |                    ^^^ use of undeclared crate or module `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/export-fully-qualified.stderr b/tests/ui/resolve/export-fully-qualified.stderr
index a8af0c7c9b8..869149d8d3c 100644
--- a/tests/ui/resolve/export-fully-qualified.stderr
+++ b/tests/ui/resolve/export-fully-qualified.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `foo`
 LL |     pub fn bar() { foo::baz(); }
    |                    ^^^ use of undeclared crate or module `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/fn-new-doesnt-exist.stderr b/tests/ui/resolve/fn-new-doesnt-exist.stderr
index 39adc0fde44..418dd9ea6b8 100644
--- a/tests/ui/resolve/fn-new-doesnt-exist.stderr
+++ b/tests/ui/resolve/fn-new-doesnt-exist.stderr
@@ -9,6 +9,6 @@ note: if you're trying to build a new `TcpStream` consider using one of the foll
       TcpStream::connect_timeout
   --> $SRC_DIR/std/src/net/tcp.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/resolve/impl-items-vis-unresolved.stderr b/tests/ui/resolve/impl-items-vis-unresolved.stderr
index f2293d28ea1..cccffdcbf54 100644
--- a/tests/ui/resolve/impl-items-vis-unresolved.stderr
+++ b/tests/ui/resolve/impl-items-vis-unresolved.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: there are too many leading `super` keywords
 LL |         pub(super) fn new() {}
    |             ^^^^^ there are too many leading `super` keywords
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/issue-101749-2.stderr b/tests/ui/resolve/issue-101749-2.stderr
index 370d4b14540..300aaf26cb7 100644
--- a/tests/ui/resolve/issue-101749-2.stderr
+++ b/tests/ui/resolve/issue-101749-2.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `rect`
 LL |     let _ = rect::area();
    |             ^^^^ use of undeclared crate or module `rect`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/issue-101749.stderr b/tests/ui/resolve/issue-101749.stderr
index dd29d7fc051..05515b1b460 100644
--- a/tests/ui/resolve/issue-101749.stderr
+++ b/tests/ui/resolve/issue-101749.stderr
@@ -9,6 +9,6 @@ help: you may have meant to call an instance method
 LL |     let _ = rect.area();
    |                 ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/issue-10200.stderr b/tests/ui/resolve/issue-10200.stderr
index e60489f5b82..7b218694b26 100644
--- a/tests/ui/resolve/issue-10200.stderr
+++ b/tests/ui/resolve/issue-10200.stderr
@@ -7,6 +7,6 @@ LL | struct Foo(bool);
 LL |         foo(x)
    |         ^^^ help: a tuple struct with a similar name exists (notice the capitalization): `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/resolve/issue-103202.stderr b/tests/ui/resolve/issue-103202.stderr
index d4d141fb06f..87fa940ac3b 100644
--- a/tests/ui/resolve/issue-103202.stderr
+++ b/tests/ui/resolve/issue-103202.stderr
@@ -9,6 +9,6 @@ help: if there were a trait named `Example` with associated type `x` implemented
 LL |     fn f(self: &<S as Example>::x) {}
    |                 ~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/resolve/issue-105069.stderr b/tests/ui/resolve/issue-105069.stderr
index a049cac830a..5e87ccf4132 100644
--- a/tests/ui/resolve/issue-105069.stderr
+++ b/tests/ui/resolve/issue-105069.stderr
@@ -18,6 +18,6 @@ LL | use self::B::*;
    |     ^^^^^^^^^^
    = help: consider adding an explicit import of `V` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/resolve/issue-108529.stderr b/tests/ui/resolve/issue-108529.stderr
index cf4e4759c37..ef1a6c919ee 100644
--- a/tests/ui/resolve/issue-108529.stderr
+++ b/tests/ui/resolve/issue-108529.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `f::f`
 LL | use f::f::f;
    |        ^ expected type, found associated function `f` in `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/resolve/issue-109153.stderr b/tests/ui/resolve/issue-109153.stderr
index 1a345d2a3e3..da95029f6e7 100644
--- a/tests/ui/resolve/issue-109153.stderr
+++ b/tests/ui/resolve/issue-109153.stderr
@@ -18,6 +18,6 @@ LL | use bar::*;
    |     ^^^^^^
    = help: consider adding an explicit import of `bar` to disambiguate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/resolve/issue-109250.stderr b/tests/ui/resolve/issue-109250.stderr
index d5b8c08ced7..ad6cc698622 100644
--- a/tests/ui/resolve/issue-109250.stderr
+++ b/tests/ui/resolve/issue-109250.stderr
@@ -9,6 +9,6 @@ help: consider importing this struct
 LL + use std::collections::HashMap;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/issue-111312.stderr b/tests/ui/resolve/issue-111312.stderr
index 4c864029c98..7e7ef22ae61 100644
--- a/tests/ui/resolve/issue-111312.stderr
+++ b/tests/ui/resolve/issue-111312.stderr
@@ -10,6 +10,6 @@ note: `Has` defines an item `has`
 LL | trait Has {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/resolve/issue-111727.stderr b/tests/ui/resolve/issue-111727.stderr
index bd748211ed3..b58168d0e75 100644
--- a/tests/ui/resolve/issue-111727.stderr
+++ b/tests/ui/resolve/issue-111727.stderr
@@ -4,6 +4,6 @@ error[E0599]: no function or associated item named `create` found for trait `Any
 LL |     std::any::Any::create();
    |                    ^^^^^^ function or associated item not found in `Any`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/resolve/issue-116164.stderr b/tests/ui/resolve/issue-116164.stderr
index 5820a189fd5..8880242c195 100644
--- a/tests/ui/resolve/issue-116164.stderr
+++ b/tests/ui/resolve/issue-116164.stderr
@@ -9,6 +9,6 @@ help: consider importing this unit variant
 LL + use inner::Example::ExOne;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/issue-12796.stderr b/tests/ui/resolve/issue-12796.stderr
index ef59d00360b..6809fd50f74 100644
--- a/tests/ui/resolve/issue-12796.stderr
+++ b/tests/ui/resolve/issue-12796.stderr
@@ -7,6 +7,6 @@ LL |         fn inner(_: &Self) {
    |                      use of generic parameter from outer item
    |                      can't use `Self` here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/resolve/issue-16058.stderr b/tests/ui/resolve/issue-16058.stderr
index 710002a154e..914990c35ff 100644
--- a/tests/ui/resolve/issue-16058.stderr
+++ b/tests/ui/resolve/issue-16058.stderr
@@ -13,6 +13,6 @@ LL + use std::io::Result;
 LL + use std::thread::Result;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/resolve/issue-17518.stderr b/tests/ui/resolve/issue-17518.stderr
index 492e3b34a17..3eba715188b 100644
--- a/tests/ui/resolve/issue-17518.stderr
+++ b/tests/ui/resolve/issue-17518.stderr
@@ -9,6 +9,6 @@ help: consider importing this variant
 LL + use SomeEnum::E;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/resolve/issue-18252.stderr b/tests/ui/resolve/issue-18252.stderr
index d9006c0a6c2..511b8da716f 100644
--- a/tests/ui/resolve/issue-18252.stderr
+++ b/tests/ui/resolve/issue-18252.stderr
@@ -4,6 +4,6 @@ error[E0533]: expected value, found struct variant `Foo::Variant`
 LL |     let f = Foo::Variant(42);
    |             ^^^^^^^^^^^^ not a value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0533`.
diff --git a/tests/ui/resolve/issue-21221-2.stderr b/tests/ui/resolve/issue-21221-2.stderr
index 9beb626623e..3bd4c1a5d13 100644
--- a/tests/ui/resolve/issue-21221-2.stderr
+++ b/tests/ui/resolve/issue-21221-2.stderr
@@ -11,6 +11,6 @@ LL + use baz::T;
 LL + use foo::bar::T;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/resolve/issue-21221-3.stderr b/tests/ui/resolve/issue-21221-3.stderr
index 0dabdfd9b39..ed3eb2dfb23 100644
--- a/tests/ui/resolve/issue-21221-3.stderr
+++ b/tests/ui/resolve/issue-21221-3.stderr
@@ -9,6 +9,6 @@ help: consider importing this trait
 LL + use issue_21221_3::outer::OuterTrait;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/resolve/issue-21221-4.stderr b/tests/ui/resolve/issue-21221-4.stderr
index 5af14b1b68d..482a3bd54a3 100644
--- a/tests/ui/resolve/issue-21221-4.stderr
+++ b/tests/ui/resolve/issue-21221-4.stderr
@@ -9,6 +9,6 @@ help: consider importing this trait
 LL + use issue_21221_4::T;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/resolve/issue-2330.stderr b/tests/ui/resolve/issue-2330.stderr
index 877cf68b586..8ac8a6dc411 100644
--- a/tests/ui/resolve/issue-2330.stderr
+++ b/tests/ui/resolve/issue-2330.stderr
@@ -4,6 +4,6 @@ error[E0404]: expected trait, found enum `Chan`
 LL | impl Chan for isize {
    |      ^^^^ not a trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/resolve/issue-23305.stderr b/tests/ui/resolve/issue-23305.stderr
index aad1b583a32..e522e461efc 100644
--- a/tests/ui/resolve/issue-23305.stderr
+++ b/tests/ui/resolve/issue-23305.stderr
@@ -6,5 +6,5 @@ LL | impl dyn ToNbt<Self> {}
    |
    = note: replace `Self` with a different type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/issue-26545.stderr b/tests/ui/resolve/issue-26545.stderr
index 42a7531c5b9..ced19ea1819 100644
--- a/tests/ui/resolve/issue-26545.stderr
+++ b/tests/ui/resolve/issue-26545.stderr
@@ -9,6 +9,6 @@ help: consider importing this tuple struct
 LL +     use foo::B;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/issue-3021.stderr b/tests/ui/resolve/issue-3021.stderr
index d5b015eec35..5dc4f9542fe 100644
--- a/tests/ui/resolve/issue-3021.stderr
+++ b/tests/ui/resolve/issue-3021.stderr
@@ -6,6 +6,6 @@ LL |            self.v0 = k0 ^ 0x736f6d6570736575;
    |
    = help: use the `|| { ... }` closure form instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0434`.
diff --git a/tests/ui/resolve/issue-30535.stderr b/tests/ui/resolve/issue-30535.stderr
index e3692934b62..0fa96a87482 100644
--- a/tests/ui/resolve/issue-30535.stderr
+++ b/tests/ui/resolve/issue-30535.stderr
@@ -7,6 +7,6 @@ LL |     _: foo::Foo::FooV
    |        not a type
    |        help: try using the variant's enum: `foo::Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0573`.
diff --git a/tests/ui/resolve/issue-3099-a.stderr b/tests/ui/resolve/issue-3099-a.stderr
index e3733cebba5..a092f562d38 100644
--- a/tests/ui/resolve/issue-3099-a.stderr
+++ b/tests/ui/resolve/issue-3099-a.stderr
@@ -9,6 +9,6 @@ LL | enum A { D, E }
    |
    = note: `A` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/resolve/issue-3099-b.stderr b/tests/ui/resolve/issue-3099-b.stderr
index c0cfefeb940..7817ab40172 100644
--- a/tests/ui/resolve/issue-3099-b.stderr
+++ b/tests/ui/resolve/issue-3099-b.stderr
@@ -9,6 +9,6 @@ LL | pub mod a {}
    |
    = note: `a` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/resolve/issue-31845.stderr b/tests/ui/resolve/issue-31845.stderr
index 56281938559..e65b911151f 100644
--- a/tests/ui/resolve/issue-31845.stderr
+++ b/tests/ui/resolve/issue-31845.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `g` in this scope
 LL |            g();
    |            ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/issue-33876.stderr b/tests/ui/resolve/issue-33876.stderr
index 52308f2a7f0..12e1b4b0bd3 100644
--- a/tests/ui/resolve/issue-33876.stderr
+++ b/tests/ui/resolve/issue-33876.stderr
@@ -4,6 +4,6 @@ error[E0423]: expected value, found trait `Bar`
 LL |     let any: &dyn Any = &Bar;
    |                          ^^^ not a value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/issue-3907-2.stderr b/tests/ui/resolve/issue-3907-2.stderr
index 782cfeec4bc..2693daa3c7a 100644
--- a/tests/ui/resolve/issue-3907-2.stderr
+++ b/tests/ui/resolve/issue-3907-2.stderr
@@ -10,6 +10,6 @@ note: for a trait to be "object safe" it needs to allow building a vtable to all
 LL |     fn bar();
    |        ^^^ the trait cannot be made into an object because associated function `bar` has no `self` parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/resolve/issue-3907.stderr b/tests/ui/resolve/issue-3907.stderr
index 70631a13cdf..e9dc344496e 100644
--- a/tests/ui/resolve/issue-3907.stderr
+++ b/tests/ui/resolve/issue-3907.stderr
@@ -13,6 +13,6 @@ help: consider importing this trait instead
 LL + use issue_3907::Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/resolve/issue-39226.stderr b/tests/ui/resolve/issue-39226.stderr
index 5045ec6c30e..857f6a73517 100644
--- a/tests/ui/resolve/issue-39226.stderr
+++ b/tests/ui/resolve/issue-39226.stderr
@@ -16,6 +16,6 @@ help: a local variable with a similar name exists
 LL |         handle: handle
    |                 ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/issue-39559.stderr b/tests/ui/resolve/issue-39559.stderr
index 7626f827fc5..e7d26d63be3 100644
--- a/tests/ui/resolve/issue-39559.stderr
+++ b/tests/ui/resolve/issue-39559.stderr
@@ -7,5 +7,5 @@ LL |     entries: [T; D::dim()],
    = note: type parameters may not be used in const expressions
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/issue-5035-2.stderr b/tests/ui/resolve/issue-5035-2.stderr
index 558e6b7b118..8eeb398f077 100644
--- a/tests/ui/resolve/issue-5035-2.stderr
+++ b/tests/ui/resolve/issue-5035-2.stderr
@@ -15,6 +15,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn foo(_x: &K) {}
    |            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/resolve/issue-50599.stderr b/tests/ui/resolve/issue-50599.stderr
index d58b6ca5b5c..25e98b4746b 100644
--- a/tests/ui/resolve/issue-50599.stderr
+++ b/tests/ui/resolve/issue-50599.stderr
@@ -16,6 +16,6 @@ LL -     const M: usize = (f64::from(N) * std::f64::LOG10_2) as usize;
 LL +     const M: usize = (f64::from(N) * LOG10_2) as usize;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr b/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr
index 3e9c3fd11b7..363bb556478 100644
--- a/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr
+++ b/tests/ui/resolve/issue-65025-extern-static-parent-generics.stderr
@@ -7,6 +7,6 @@ LL |     extern "C" {
 LL |         static baz: *const A;
    |                            ^ use of generic parameter from outer item
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/resolve/issue-6642.stderr b/tests/ui/resolve/issue-6642.stderr
index 6668108d024..7f1a1aa4476 100644
--- a/tests/ui/resolve/issue-6642.stderr
+++ b/tests/ui/resolve/issue-6642.stderr
@@ -6,6 +6,6 @@ LL |             self.m()
    |
    = help: use the `|| { ... }` closure form instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0434`.
diff --git a/tests/ui/resolve/issue-6702.stderr b/tests/ui/resolve/issue-6702.stderr
index a118f94191d..d1ceee3e56e 100644
--- a/tests/ui/resolve/issue-6702.stderr
+++ b/tests/ui/resolve/issue-6702.stderr
@@ -9,6 +9,6 @@ LL | | }
 LL |       let _m = Monster();
    |                ^^^^^^^^^ help: use struct literal syntax instead: `Monster { damage: val }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/issue-69401-trait-fn-no-body-ty-local.stderr b/tests/ui/resolve/issue-69401-trait-fn-no-body-ty-local.stderr
index 109409d2731..60ef13551a1 100644
--- a/tests/ui/resolve/issue-69401-trait-fn-no-body-ty-local.stderr
+++ b/tests/ui/resolve/issue-69401-trait-fn-no-body-ty-local.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `b` in this scope
 LL |     fn fn_with_type_named_same_as_local_in_param(b: b);
    |                                                     ^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/resolve/issue-80079.stderr b/tests/ui/resolve/issue-80079.stderr
index 93e8c0341a1..e300ee964be 100644
--- a/tests/ui/resolve/issue-80079.stderr
+++ b/tests/ui/resolve/issue-80079.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `Foo` in this scope
 LL |     let _ = Foo;
    |             ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/issue-82156.stderr b/tests/ui/resolve/issue-82156.stderr
index d53599dcce6..3894b9573a4 100644
--- a/tests/ui/resolve/issue-82156.stderr
+++ b/tests/ui/resolve/issue-82156.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: there are too many leading `super` keywords
 LL |     super();
    |     ^^^^^ there are too many leading `super` keywords
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/issue-90113.stderr b/tests/ui/resolve/issue-90113.stderr
index 5f55d9c241a..d25c67825e3 100644
--- a/tests/ui/resolve/issue-90113.stderr
+++ b/tests/ui/resolve/issue-90113.stderr
@@ -9,6 +9,6 @@ help: consider importing this tuple variant
 LL + use list::List::Cons;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0531`.
diff --git a/tests/ui/resolve/missing-in-namespace.stderr b/tests/ui/resolve/missing-in-namespace.stderr
index 7a7b749aebb..35585e4240a 100644
--- a/tests/ui/resolve/missing-in-namespace.stderr
+++ b/tests/ui/resolve/missing-in-namespace.stderr
@@ -14,6 +14,6 @@ LL -     let _map = std::hahmap::HashMap::new();
 LL +     let _map = HashMap::new();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/name-clash-nullary.stderr b/tests/ui/resolve/name-clash-nullary.stderr
index fffd3027afd..08e7fe9a678 100644
--- a/tests/ui/resolve/name-clash-nullary.stderr
+++ b/tests/ui/resolve/name-clash-nullary.stderr
@@ -9,6 +9,6 @@ LL |   let None: isize = 42;
    = note: expected type `isize`
               found enum `Option<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/resolve/point-at-type-parameter-shadowing-another-type.stderr b/tests/ui/resolve/point-at-type-parameter-shadowing-another-type.stderr
index 5790e425c0a..a7770e1e7e4 100644
--- a/tests/ui/resolve/point-at-type-parameter-shadowing-another-type.stderr
+++ b/tests/ui/resolve/point-at-type-parameter-shadowing-another-type.stderr
@@ -10,6 +10,6 @@ LL | impl<Baz> Foo<Baz> for Bar {
 LL |             Baz { num } => num,
    |             ^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/resolve/raw-ident-in-path.stderr b/tests/ui/resolve/raw-ident-in-path.stderr
index 771dacbbb20..7d2aa691136 100644
--- a/tests/ui/resolve/raw-ident-in-path.stderr
+++ b/tests/ui/resolve/raw-ident-in-path.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `r#break` in the crate root
 LL | type A = crate::r#break;
    |                 ^^^^^^^ not found in the crate root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/resolve/resolve-bad-import-prefix.stderr b/tests/ui/resolve/resolve-bad-import-prefix.stderr
index 852b9c6afff..36eb3148ab5 100644
--- a/tests/ui/resolve/resolve-bad-import-prefix.stderr
+++ b/tests/ui/resolve/resolve-bad-import-prefix.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `Nonexistent`
 LL | use Nonexistent::{};
    |     ^^^^^^^^^^^^^^^ no `Nonexistent` in the root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/resolve/resolve-conflict-extern-crate-vs-extern-crate.stderr b/tests/ui/resolve/resolve-conflict-extern-crate-vs-extern-crate.stderr
index ea6cb9eb00d..999e9a47d6c 100644
--- a/tests/ui/resolve/resolve-conflict-extern-crate-vs-extern-crate.stderr
+++ b/tests/ui/resolve/resolve-conflict-extern-crate-vs-extern-crate.stderr
@@ -6,6 +6,6 @@ help: you can use `as` to change the binding name of the import
 LL | extern crate std as other_std;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/resolve/resolve-conflict-import-vs-extern-crate.stderr b/tests/ui/resolve/resolve-conflict-import-vs-extern-crate.stderr
index abf068a1f68..e22e636adb6 100644
--- a/tests/ui/resolve/resolve-conflict-import-vs-extern-crate.stderr
+++ b/tests/ui/resolve/resolve-conflict-import-vs-extern-crate.stderr
@@ -10,6 +10,6 @@ help: you can use `as` to change the binding name of the import
 LL | use std::slice as other_std;
    |     ~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0254`.
diff --git a/tests/ui/resolve/resolve-conflict-import-vs-import.stderr b/tests/ui/resolve/resolve-conflict-import-vs-import.stderr
index 632be50f4c4..de33addcb23 100644
--- a/tests/ui/resolve/resolve-conflict-import-vs-import.stderr
+++ b/tests/ui/resolve/resolve-conflict-import-vs-import.stderr
@@ -8,6 +8,6 @@ LL | use std::mem::transmute;
    |
    = note: `transmute` must be defined only once in the value namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/resolve/resolve-conflict-item-vs-extern-crate.stderr b/tests/ui/resolve/resolve-conflict-item-vs-extern-crate.stderr
index 7b9fb6c63f6..1097dab415e 100644
--- a/tests/ui/resolve/resolve-conflict-item-vs-extern-crate.stderr
+++ b/tests/ui/resolve/resolve-conflict-item-vs-extern-crate.stderr
@@ -6,6 +6,6 @@ LL | mod std {}
    |
    = note: `std` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0260`.
diff --git a/tests/ui/resolve/resolve-conflict-item-vs-import.stderr b/tests/ui/resolve/resolve-conflict-item-vs-import.stderr
index 5e5c9f6b3d8..3b1b5f1ad00 100644
--- a/tests/ui/resolve/resolve-conflict-item-vs-import.stderr
+++ b/tests/ui/resolve/resolve-conflict-item-vs-import.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | use std::mem::transmute as other_transmute;
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/resolve/resolve-conflict-type-vs-import.stderr b/tests/ui/resolve/resolve-conflict-type-vs-import.stderr
index 198ef10311e..c5cb4e07862 100644
--- a/tests/ui/resolve/resolve-conflict-type-vs-import.stderr
+++ b/tests/ui/resolve/resolve-conflict-type-vs-import.stderr
@@ -13,6 +13,6 @@ help: you can use `as` to change the binding name of the import
 LL | use std::slice::Iter as OtherIter;
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0255`.
diff --git a/tests/ui/resolve/resolve-label.stderr b/tests/ui/resolve/resolve-label.stderr
index 5729348ef21..4c93cf9ea3f 100644
--- a/tests/ui/resolve/resolve-label.stderr
+++ b/tests/ui/resolve/resolve-label.stderr
@@ -9,6 +9,6 @@ LL |                 break 'l;
    |
    = note: labels are unreachable through functions, closures, async blocks and modules
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0767`.
diff --git a/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr b/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr
index d3574851d5c..de65d695dd2 100644
--- a/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr
+++ b/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr
@@ -9,6 +9,6 @@ help: consider importing this function
 LL + use y::z;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/token-error-correct-2.stderr b/tests/ui/resolve/token-error-correct-2.stderr
index be5fb18a5d8..662b849da9e 100644
--- a/tests/ui/resolve/token-error-correct-2.stderr
+++ b/tests/ui/resolve/token-error-correct-2.stderr
@@ -6,5 +6,5 @@ LL |     if foo {
 LL |     )
    |     ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/token-error-correct-3.stderr b/tests/ui/resolve/token-error-correct-3.stderr
index 79d1d4883a1..d4ca6c6b75c 100644
--- a/tests/ui/resolve/token-error-correct-3.stderr
+++ b/tests/ui/resolve/token-error-correct-3.stderr
@@ -9,5 +9,5 @@ LL |             fs::create_dir_all(path.as_ref()).map(|()| true)
 LL |         } else {
    |         ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/token-error-correct-4.stderr b/tests/ui/resolve/token-error-correct-4.stderr
index 3ec97171fd3..c4e50cdbfad 100644
--- a/tests/ui/resolve/token-error-correct-4.stderr
+++ b/tests/ui/resolve/token-error-correct-4.stderr
@@ -8,5 +8,5 @@ LL |     setsuna(kazusa();
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/token-error-correct.stderr b/tests/ui/resolve/token-error-correct.stderr
index 35b2d0b323b..5fa3703fdc3 100644
--- a/tests/ui/resolve/token-error-correct.stderr
+++ b/tests/ui/resolve/token-error-correct.stderr
@@ -8,5 +8,5 @@ LL |     foo(bar(;
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/resolve/tool-import.stderr b/tests/ui/resolve/tool-import.stderr
index d3bdfc93d49..b070439d72b 100644
--- a/tests/ui/resolve/tool-import.stderr
+++ b/tests/ui/resolve/tool-import.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: `clippy` is a tool module, not a module
 LL | use clippy::time::Instant;
    |     ^^^^^^ `clippy` is a tool module, not a module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/unresolved-segments-visibility.stderr b/tests/ui/resolve/unresolved-segments-visibility.stderr
index 0a11549cdbf..09f3c50258d 100644
--- a/tests/ui/resolve/unresolved-segments-visibility.stderr
+++ b/tests/ui/resolve/unresolved-segments-visibility.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: `String` is a struct, not a module
 LL |         pub(in b::string::String::newy) extern crate alloc as e;
    |                           ^^^^^^ `String` is a struct, not a module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/resolve/unresolved_static_type_field.stderr b/tests/ui/resolve/unresolved_static_type_field.stderr
index 035dc9b9656..e3de0a3fb74 100644
--- a/tests/ui/resolve/unresolved_static_type_field.stderr
+++ b/tests/ui/resolve/unresolved_static_type_field.stderr
@@ -7,6 +7,6 @@ LL |     cx: bool,
 LL |         f(cx);
    |           ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/use-self-in-inner-fn.stderr b/tests/ui/resolve/use-self-in-inner-fn.stderr
index 832aaacaf49..165e100bf2f 100644
--- a/tests/ui/resolve/use-self-in-inner-fn.stderr
+++ b/tests/ui/resolve/use-self-in-inner-fn.stderr
@@ -10,6 +10,6 @@ LL |         fn peach(this: &Self) {
    |                         use of generic parameter from outer item
    |                         refer to the type directly here instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0401`.
diff --git a/tests/ui/ret-non-nil.stderr b/tests/ui/ret-non-nil.stderr
index 2029c6d9d81..17567c6016a 100644
--- a/tests/ui/ret-non-nil.stderr
+++ b/tests/ui/ret-non-nil.stderr
@@ -6,6 +6,6 @@ LL | fn g() -> isize { return; }
    |           |
    |           expected `isize` because of this return type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0069`.
diff --git a/tests/ui/return-disjoint-regions.stderr b/tests/ui/return-disjoint-regions.stderr
index ed159298804..7b5b032579a 100644
--- a/tests/ui/return-disjoint-regions.stderr
+++ b/tests/ui/return-disjoint-regions.stderr
@@ -6,6 +6,6 @@ LL |     let y = &x;
 LL |     (y, y)
    |     ^^^^^^ returns a value referencing data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/return/issue-64620.stderr b/tests/ui/return/issue-64620.stderr
index 3210a67d418..3c5583da682 100644
--- a/tests/ui/return/issue-64620.stderr
+++ b/tests/ui/return/issue-64620.stderr
@@ -4,6 +4,6 @@ error[E0572]: return statement outside of function body
 LL |     V1 = return [0][0],
    |          ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/return/issue-82612-return-mutable-reference.stderr b/tests/ui/return/issue-82612-return-mutable-reference.stderr
index eb2322d51fd..59a6bb85d0f 100644
--- a/tests/ui/return/issue-82612-return-mutable-reference.stderr
+++ b/tests/ui/return/issue-82612-return-mutable-reference.stderr
@@ -23,6 +23,6 @@ help: you might have meant to return this value
 LL |             return value.get_or_insert_with(func);
    |             ++++++                               +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/return/return-from-diverging.stderr b/tests/ui/return/return-from-diverging.stderr
index 0c1fb4d9c59..2eeed960ddb 100644
--- a/tests/ui/return/return-from-diverging.stderr
+++ b/tests/ui/return/return-from-diverging.stderr
@@ -9,6 +9,6 @@ LL |     return "wow";
    = note:   expected type `!`
            found reference `&'static str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/return/return-type.stderr b/tests/ui/return/return-type.stderr
index 60d538eba88..1757fcac6e2 100644
--- a/tests/ui/return/return-type.stderr
+++ b/tests/ui/return/return-type.stderr
@@ -15,6 +15,6 @@ help: try adding a return type
 LL | fn bar() -> S<usize> {
    |          +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/return/return-unit-from-diverging.stderr b/tests/ui/return/return-unit-from-diverging.stderr
index befc57563a9..0ce161e24b3 100644
--- a/tests/ui/return/return-unit-from-diverging.stderr
+++ b/tests/ui/return/return-unit-from-diverging.stderr
@@ -6,6 +6,6 @@ LL | fn fail() -> ! {
 LL |     return;
    |     ^^^^^^ return type is not `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0069`.
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr
index f08ba522a93..334bd7618ad 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-embedded.stderr
@@ -7,5 +7,5 @@ LL |         WRAP_DIRECT_INLINE => { panic!("WRAP_DIRECT_INLINE matched itself")
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr
index 012ccab176c..58bfcbb451d 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr
@@ -7,5 +7,5 @@ LL |         WRAP_DIRECT_PARAM => { panic!("WRAP_DIRECT_PARAM matched itself");
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/feature-gate.with_gate.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/feature-gate.with_gate.stderr
index 623fd585acc..505b7d79cad 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/feature-gate.with_gate.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/feature-gate.with_gate.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-61188-match-slice-forbidden-without-eq.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-61188-match-slice-forbidden-without-eq.stderr
index 46600e7b215..729e747def3 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-61188-match-slice-forbidden-without-eq.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-61188-match-slice-forbidden-without-eq.stderr
@@ -7,5 +7,5 @@ LL |         A => (),
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-forbidden-without-eq.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-forbidden-without-eq.stderr
index 1c4fb914688..c2000df88f6 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-forbidden-without-eq.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-forbidden-without-eq.stderr
@@ -17,5 +17,5 @@ LL |         f32::INFINITY => { }
    = note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
    = note: `#[warn(illegal_floating_point_literal_pattern)]` on by default
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-nonempty-array-forbidden-without-eq.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-nonempty-array-forbidden-without-eq.stderr
index 6adebada043..477789f33df 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-nonempty-array-forbidden-without-eq.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-nonempty-array-forbidden-without-eq.stderr
@@ -7,5 +7,5 @@ LL |         FOO => { }
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr
index f5b10f0626b..b806046db14 100644
--- a/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr
+++ b/tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/match-requires-both-partialeq-and-eq.stderr
@@ -7,5 +7,5 @@ LL |         FOO => { }
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1717-dllimport/missing-link-attr.stderr b/tests/ui/rfcs/rfc-1717-dllimport/missing-link-attr.stderr
index d4410e14750..4218ef31e20 100644
--- a/tests/ui/rfcs/rfc-1717-dllimport/missing-link-attr.stderr
+++ b/tests/ui/rfcs/rfc-1717-dllimport/missing-link-attr.stderr
@@ -1,4 +1,4 @@
 error: renaming of the library `foo` was specified, however this crate contains no `#[link(...)]` attributes referencing this library
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1717-dllimport/multiple-renames.stderr b/tests/ui/rfcs/rfc-1717-dllimport/multiple-renames.stderr
index a6fec9c4e2b..d931e23c756 100644
--- a/tests/ui/rfcs/rfc-1717-dllimport/multiple-renames.stderr
+++ b/tests/ui/rfcs/rfc-1717-dllimport/multiple-renames.stderr
@@ -1,4 +1,4 @@
 error: multiple renamings were specified for library `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1717-dllimport/rename-modifiers.stderr b/tests/ui/rfcs/rfc-1717-dllimport/rename-modifiers.stderr
index bee639bf26c..ce145689f90 100644
--- a/tests/ui/rfcs/rfc-1717-dllimport/rename-modifiers.stderr
+++ b/tests/ui/rfcs/rfc-1717-dllimport/rename-modifiers.stderr
@@ -4,5 +4,5 @@ error: overriding linking modifiers from command line is not supported
 LL | extern "C" {}
    | ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1717-dllimport/rename-to-empty.stderr b/tests/ui/rfcs/rfc-1717-dllimport/rename-to-empty.stderr
index aca839d804f..c208e050320 100644
--- a/tests/ui/rfcs/rfc-1717-dllimport/rename-to-empty.stderr
+++ b/tests/ui/rfcs/rfc-1717-dllimport/rename-to-empty.stderr
@@ -1,4 +1,4 @@
 error: an empty renaming target was specified for library `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-1.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-1.stderr
index 409dede1a90..6c3d576cfba 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-1.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-1.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `receive`
 LL | fn receive(_: impl std::process::Termination) {}
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `receive`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.stderr
index 40f736c215d..3fbbfd0fd0d 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Main::{opaque#0}`
 LL |         fn main() -> impl std::process::Termination;
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Main::{opaque#0}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-impl-trait.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-impl-trait.stderr
index 5ee6d127e85..f562b97c344 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-impl-trait.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-impl-trait.stderr
@@ -6,6 +6,6 @@ LL | fn main() -> impl Copy { }
    |
    = help: consider using `()`, or a `Result`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-in-test-should-panic.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-in-test-should-panic.stderr
index 7f6749fc9cc..534599b74df 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-in-test-should-panic.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-in-test-should-panic.stderr
@@ -8,5 +8,5 @@ LL | |     Ok(())
 LL | | }
    | |_^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-i32.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-i32.stderr
index 53779d365f3..fdbb0e6559d 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-i32.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-i32.stderr
@@ -6,6 +6,6 @@ LL | fn main() -> i32 {
    |
    = help: consider using `()`, or a `Result`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-wrong-type.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-wrong-type.stderr
index bc8fd92ce58..7ed17dff10c 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-wrong-type.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-main-wrong-type.stderr
@@ -6,6 +6,6 @@ LL | fn main() -> char {
    |
    = help: consider using `()`, or a `Result`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-not-satisfied.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-not-satisfied.stderr
index cb329548d86..1b842c206ee 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-not-satisfied.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-not-satisfied.stderr
@@ -6,6 +6,6 @@ LL | fn main() -> ReturnType {
    |
    = help: consider using `()`, or a `Result`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr
index a19750cc73a..0a703367d96 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/termination-trait-test-wrong-type.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `assert_test_result`
   --> $SRC_DIR/test/src/lib.rs:LL:COL
    = note: this error originates in the attribute macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/borrowck-issue-49631.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/borrowck-issue-49631.stderr
index 04572920ee4..a9c9eb2a5cb 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/borrowck-issue-49631.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/borrowck-issue-49631.stderr
@@ -9,6 +9,6 @@ LL |
 LL |         println!("foo={:?}", *string);
    |                              ------- immutable borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr
index fc06de90a00..1c8e8d5b0a7 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/const.stderr
@@ -13,6 +13,6 @@ LL |         FOO => {},
    |         `FOO` is interpreted as a constant, not a new binding
    |         help: introduce a new binding instead: `other_foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr
index 07991af6ef9..8f720daf11e 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/for.stderr
@@ -12,6 +12,6 @@ help: consider borrowing the pattern binding
 LL |     for (n, ref mut m) in &tups {
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/issue-44912-or.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/issue-44912-or.stderr
index e1e1bf7f6d9..84ba69703da 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/issue-44912-or.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/issue-44912-or.stderr
@@ -4,6 +4,6 @@ error[E0409]: variable `x` is bound inconsistently across alternatives separated
 LL |         Some((x, 3)) | &Some((ref x, 5)) => x,
    |               - first binding     ^ bound in different ways
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0409`.
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr
index c672acee040..6000507c589 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/no-double-error.stderr
@@ -4,6 +4,6 @@ error[E0599]: no associated item named `XXX` found for type `u32` in the current
 LL |         u32::XXX => { }
    |              ^^^ associated item not found in `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/slice.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/slice.stderr
index 5b51dc5acc4..a83c58e7007 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/slice.stderr
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/slice.stderr
@@ -11,6 +11,6 @@ LL ~         [first, remainder @ ..] => {},
 LL ~         &[] => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/borrowck-non-exhaustive.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/borrowck-non-exhaustive.stderr
index ad84ebe3a50..70f5b2b84d8 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/borrowck-non-exhaustive.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/borrowck-non-exhaustive.stderr
@@ -9,6 +9,6 @@ LL |     match x {
 LL |     drop(y);
    |          - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum-as-cast.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum-as-cast.stderr
index a61dcf8399f..c8dad8b807a 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum-as-cast.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum-as-cast.stderr
@@ -6,6 +6,6 @@ LL |     let d = e as u8;
    |
    = note: cannot cast an enum with a non-exhaustive variant when it's defined in another crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/omitted-patterns-dont-lint-on-arm.normal.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/omitted-patterns-dont-lint-on-arm.normal.stderr
index 46093eb9fb3..2535e051807 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/omitted-patterns-dont-lint-on-arm.normal.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/omitted-patterns-dont-lint-on-arm.normal.stderr
@@ -27,5 +27,5 @@ LL +     #[deny(non_exhaustive_omitted_patterns)]
 LL |     match val {
    |
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/stable-omitted-patterns.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/stable-omitted-patterns.stderr
index 27939176f75..2658b20a726 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/stable-omitted-patterns.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/stable-omitted-patterns.stderr
@@ -26,5 +26,5 @@ note: the lint level is defined here
 LL |     #[deny(non_exhaustive_omitted_patterns)]
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/issue-65157-repeated-match-arm.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/issue-65157-repeated-match-arm.stderr
index f39e6ee2985..3034a67dc43 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/issue-65157-repeated-match-arm.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/issue-65157-repeated-match-arm.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-odd-syntax.stderr b/tests/ui/rfcs/rfc-2091-track-caller/error-odd-syntax.stderr
index e7ddf8df4ab..e22d812c8b0 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-odd-syntax.stderr
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-odd-syntax.stderr
@@ -4,5 +4,5 @@ error: malformed `track_caller` attribute input
 LL | #[track_caller(1)]
    | ^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[track_caller]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-main.stderr b/tests/ui/rfcs/rfc-2091-track-caller/error-with-main.stderr
index 6d6562dae3b..4626544a5cd 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-with-main.stderr
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-with-main.stderr
@@ -6,5 +6,5 @@ LL | #[track_caller]
 LL | fn main() {
    | --------- `main` function is not allowed to be `#[track_caller]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-start.stderr b/tests/ui/rfcs/rfc-2091-track-caller/error-with-start.stderr
index b6ef6215275..2738444f21f 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/error-with-start.stderr
+++ b/tests/ui/rfcs/rfc-2091-track-caller/error-with-start.stderr
@@ -6,5 +6,5 @@ LL | #[track_caller]
 LL | fn start(_argc: isize, _argv: *const *const u8) -> isize {
    | -------------------------------------------------------- `#[start]` function is not allowed to be `#[track_caller]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/only-for-fns.stderr b/tests/ui/rfcs/rfc-2091-track-caller/only-for-fns.stderr
index b36597bded9..f976b7f5210 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/only-for-fns.stderr
+++ b/tests/ui/rfcs/rfc-2091-track-caller/only-for-fns.stderr
@@ -6,6 +6,6 @@ LL | #[track_caller]
 LL | struct S;
    | --------- not a function definition
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0739`.
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr
index 76300cce55c..e2a92cf72d5 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, T> {
    |
    = note: T: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
index 041f7ebc0aa..b0f1d7b33e4 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
@@ -17,6 +17,6 @@ help: consider adding an explicit lifetime bound
 LL | struct Foo<U: 'static> {
    |             +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr
index 595a5c28088..30d1b3e77b1 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, A>
    |
    = note: A: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr
index 3059f95aefb..afc044d8848 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr
@@ -6,5 +6,5 @@ LL | enum Foo<'a, U> {
    |
    = note: U: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr
index 589e9589913..1c39c984a2a 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, A, B> where A: Trait<'a, B>
    |
    = note: B: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr
index 9912e36b29c..4ec3087acff 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'b, U> {
    |
    = note: U: 'b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr
index 16b64bdc29d..bbb48ef1f26 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr
@@ -6,5 +6,5 @@ LL | union Foo<'b, U: Copy> {
    |
    = note: U: 'b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr
index 4350e6e8bee..b584d17ae85 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr
@@ -6,5 +6,5 @@ LL | enum Foo<'a, T> {
    |
    = note: T: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr
index c08add7eded..59df869c47a 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr
@@ -8,5 +8,5 @@ LL | struct Foo<'a, 'b, T> {
    = note: T: 'a
    = note: T: 'b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr
index 76955523443..7e5af7fe6ed 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, T> {
    |
    = note: T: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr
index a785c63ce3d..bb0eea027d5 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr
@@ -6,5 +6,5 @@ LL | union Foo<'a, T: Copy> {
    |
    = note: T: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr
index d9342013f55..47f3458e086 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, T: Iterator> {
    |
    = note: <T as Iterator>::Item: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr
index 50811435781..329d5ff06ab 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, T> {
    |
    = note: T: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region-rev.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region-rev.stderr
index 5dff4c8fffc..591585c88f5 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region-rev.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region-rev.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL |     impl<'a, 'b> Trait<'a, 'b> for usize {
    |              ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region.stderr
index 975776cddff..0404b52d9ef 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-region.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL |     impl<'a, 'b> Trait<'a, 'b> for usize {
    |              ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type-rev.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type-rev.stderr
index be05ecec0c9..62415e250ec 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type-rev.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type-rev.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL |     impl<'a, 'b> Trait<'a, 'b> for usize {
    |              ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type.stderr
index 4ba1778d644..464d7968b74 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-outlives-nominal-type-type.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'b` as defined her
 LL |     impl<'a, 'b> Trait<'a, 'b> for usize {
    |              ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr
index 9c836b190cf..8f8ee920547 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, 'b, A>
    |
    = note: A: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr
index 2b4625f77a5..7fef81c2619 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr
@@ -6,5 +6,5 @@ LL | struct Foo<'a, 'b, T> {
    |
    = note: T: 'a
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2126-crate-paths/keyword-crate-as-identifier.stderr b/tests/ui/rfcs/rfc-2126-crate-paths/keyword-crate-as-identifier.stderr
index c39a70f66a9..771a09abedc 100644
--- a/tests/ui/rfcs/rfc-2126-crate-paths/keyword-crate-as-identifier.stderr
+++ b/tests/ui/rfcs/rfc-2126-crate-paths/keyword-crate-as-identifier.stderr
@@ -4,6 +4,6 @@ error[E0532]: expected unit struct, unit variant or constant, found module `crat
 LL |     let crate = 0;
    |         ^^^^^ not a unit struct, unit variant or constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0532`.
diff --git a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-1.stderr b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-1.stderr
index 81891572179..1047dbe1063 100644
--- a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-1.stderr
+++ b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-1.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `xcrate`
 LL | use xcrate::S;
    |     ^^^^^^ use of undeclared crate or module `xcrate`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-2.stderr b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-2.stderr
index 7df4f06d1c7..e3875fd843b 100644
--- a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-2.stderr
+++ b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-2.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: could not find `xcrate` in the list of imported
 LL |     let s = ::xcrate::S;
    |               ^^^^^^ could not find `xcrate` in the list of imported crates
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-3.stderr b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-3.stderr
index bd6778cf3d6..c321f3ede2d 100644
--- a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-3.stderr
+++ b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/non-existent-3.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `ycrate`
 LL | use ycrate;
    |     ^^^^^^ no external crate `ycrate`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/not-allowed.stderr b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/not-allowed.stderr
index 122e8fd350c..7f989c15f1c 100644
--- a/tests/ui/rfcs/rfc-2126-extern-absolute-paths/not-allowed.stderr
+++ b/tests/ui/rfcs/rfc-2126-extern-absolute-paths/not-allowed.stderr
@@ -11,6 +11,6 @@ LL | use core::alloc;
 LL | use std::alloc;
    |     ~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/guard-lifetime-1.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/guard-lifetime-1.stderr
index b8e1bb324b1..741ae7c92d7 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/guard-lifetime-1.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/guard-lifetime-1.stderr
@@ -10,6 +10,6 @@ LL |
 LL |             let _z: &String = z;
    |                               - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-1.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-1.stderr
index 009d153387e..98285f5c3e1 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-1.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-1.stderr
@@ -6,6 +6,6 @@ LL |         Some(mut y) if let Some(ref mut z) = y => {
    |
    = note: variables bound in patterns are immutable until the end of the pattern guard
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-2.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-2.stderr
index 07e7c6a2c07..31df8a922ac 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-2.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-2.stderr
@@ -6,6 +6,6 @@ LL |         Some(ref mut y) if let Some(ref mut z) = *y => {
    |
    = note: variables bound in patterns are immutable until the end of the pattern guard
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr
index 00c1c303d2b..b8065b9f556 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr
@@ -10,5 +10,5 @@ LL |         () if m!(Some(5)) => {}
    = note: only supported directly in conditions of `if` and `while` expressions
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
index 9dc339abc06..c2b9899e20d 100644
--- a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
+++ b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
@@ -10,6 +10,6 @@ LL |     let _ = dbg!(a);
    |
    = note: this error originates in the macro `dbg` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-requires-debug.stderr b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-requires-debug.stderr
index ce165e64632..7ec018a95cc 100644
--- a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-requires-debug.stderr
+++ b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-requires-debug.stderr
@@ -13,6 +13,6 @@ LL + #[derive(Debug)]
 LL | struct NotDebug;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/feature-gate-target_feature_11.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/feature-gate-target_feature_11.stderr
index 18917fd2556..06c6c905338 100644
--- a/tests/ui/rfcs/rfc-2396-target_feature-11/feature-gate-target_feature_11.stderr
+++ b/tests/ui/rfcs/rfc-2396-target_feature-11/feature-gate-target_feature_11.stderr
@@ -9,6 +9,6 @@ LL | fn foo() {}
    = note: see issue #69098 <https://github.com/rust-lang/rust/issues/69098> for more information
    = help: add `#![feature(target_feature_11)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.mir.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.mir.stderr
index e08ffe42d6a..7bbd4e15898 100644
--- a/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.mir.stderr
+++ b/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.mir.stderr
@@ -18,6 +18,6 @@ help: consider casting to a fn pointer
 LL |     let foo: fn() = foo as fn();
    |                     ~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.thir.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.thir.stderr
index e08ffe42d6a..7bbd4e15898 100644
--- a/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.thir.stderr
+++ b/tests/ui/rfcs/rfc-2396-target_feature-11/fn-ptr.thir.stderr
@@ -18,6 +18,6 @@ help: consider casting to a fn pointer
 LL |     let foo: fn() = foo as fn();
    |                     ~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-main.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-main.stderr
index cfafbd52286..57ad1cc8d08 100644
--- a/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-main.stderr
+++ b/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-main.stderr
@@ -4,5 +4,5 @@ error: `main` function is not allowed to have `#[target_feature]`
 LL | fn main() {}
    | ^^^^^^^^^ `main` function is not allowed to have `#[target_feature]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-start.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-start.stderr
index b49f8afd960..d0a67c4f6a8 100644
--- a/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-start.stderr
+++ b/tests/ui/rfcs/rfc-2396-target_feature-11/issue-108645-target-feature-on-start.stderr
@@ -7,5 +7,5 @@ LL |
 LL | fn start(_argc: isize, _argv: *const *const u8) -> isize { 0 }
    | -------------------------------------------------------- `#[start]` function is not allowed to have `#[target_feature]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr b/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr
index a3e559054f9..6af1d4533b7 100644
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr
+++ b/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr
@@ -20,6 +20,6 @@ note: required by a bound in `stuff`
 LL | fn stuff<T: Bar>(_: T) {}
    |             ^^^ required by this bound in `stuff`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr b/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr
index 1597e5be45f..b2c1406d093 100644
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr
+++ b/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr
@@ -7,6 +7,6 @@ LL | #[do_not_recommend]
    = note: see issue #51992 <https://github.com/rust-lang/rust/issues/51992> for more information
    = help: add `#![feature(do_not_recommend)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2457-non-ascii-idents/crate_name_nonascii_forbidden.stderr b/tests/ui/rfcs/rfc-2457-non-ascii-idents/crate_name_nonascii_forbidden.stderr
index 5aade17cba5..cb663401e1e 100644
--- a/tests/ui/rfcs/rfc-2457-non-ascii-idents/crate_name_nonascii_forbidden.stderr
+++ b/tests/ui/rfcs/rfc-2457-non-ascii-idents/crate_name_nonascii_forbidden.stderr
@@ -4,5 +4,5 @@ error: cannot load a crate with a non-ascii name `ьаг`
 LL | extern crate ьаг;
    | ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/avoid-invalid-mir.stderr b/tests/ui/rfcs/rfc-2497-if-let-chains/avoid-invalid-mir.stderr
index 3eaccde3b74..606f808f093 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/avoid-invalid-mir.stderr
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/avoid-invalid-mir.stderr
@@ -6,5 +6,5 @@ LL |     !let y = 42;
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2528-type-changing-struct-update/issue-92010-trait-bound-not-satisfied.stderr b/tests/ui/rfcs/rfc-2528-type-changing-struct-update/issue-92010-trait-bound-not-satisfied.stderr
index 831731ba474..61aae850a94 100644
--- a/tests/ui/rfcs/rfc-2528-type-changing-struct-update/issue-92010-trait-bound-not-satisfied.stderr
+++ b/tests/ui/rfcs/rfc-2528-type-changing-struct-update/issue-92010-trait-bound-not-satisfied.stderr
@@ -7,6 +7,6 @@ LL |     fn y(&self, y: f64) -> Self { P{y, .. self.clone() } }
    = note: expected struct `P<T>`
            found reference `&P<T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/rfcs/rfc-2528-type-changing-struct-update/lifetime-update.stderr b/tests/ui/rfcs/rfc-2528-type-changing-struct-update/lifetime-update.stderr
index 1c26eb8803d..8ae7691a484 100644
--- a/tests/ui/rfcs/rfc-2528-type-changing-struct-update/lifetime-update.stderr
+++ b/tests/ui/rfcs/rfc-2528-type-changing-struct-update/lifetime-update.stderr
@@ -13,6 +13,6 @@ LL |     let m2: Machine<'static, State1> = Machine {
 LL | }
    | - `s` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-2018.stderr b/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-2018.stderr
index 593821bf961..0c269a23f49 100644
--- a/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-2018.stderr
+++ b/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-2018.stderr
@@ -18,5 +18,5 @@ help: if this is a type, explicitly ignore the parameter name
 LL | trait Trait2015 { fn foo(#[allow(C)] _: i32); }
    |                                      ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/raw-dylib-windows-only.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/raw-dylib-windows-only.stderr
index b635a09afba..ede20cb8c3f 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/raw-dylib-windows-only.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/raw-dylib-windows-only.stderr
@@ -4,6 +4,6 @@ error[E0455]: link kind `raw-dylib` is only supported on Windows targets
 LL | #[link(name = "foo", kind = "raw-dylib")]
    |                             ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0455`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-const-trait-method-fail.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-const-trait-method-fail.stderr
index 452bf757df7..8d809907a53 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-const-trait-method-fail.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-const-trait-method-fail.stderr
@@ -6,6 +6,6 @@ LL |     a.plus(b)
    |
    = help: the trait `Plus` is implemented for `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr
index 02d53cc78ee..4007fd455f8 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-in-impl.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | impl<T: ~const PartialEq> const MyPartialEq for T {
    |                ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr
index bea1846e79b..1f7cf689e95 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/call-generic-method-pass.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | const fn equals_self<T: ~const PartialEq>(t: &T) -> bool {
    |                                ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-check-fns-in-const-impl.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-check-fns-in-const-impl.stderr
index c8783de4c3e..ae035b26ec5 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-check-fns-in-const-impl.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-check-fns-in-const-impl.stderr
@@ -6,6 +6,6 @@ LL |     fn foo() { non_const() }
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-parse-not-item.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-parse-not-item.stderr
index f25390a9070..fc9b5557a64 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-parse-not-item.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-parse-not-item.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | const fn test() -> impl ~const Fn() {
    |                                ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method-fail.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method-fail.stderr
index 4c45b0e56c6..73ee0f2151a 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method-fail.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method-fail.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | const fn need_const_closure<T: ~const FnOnce(()) -> i32>(x: T) -> i32 {
    |                                       ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method.stderr
index a8ef244ea30..33ae7131b92 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-closure-trait-method.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | const fn need_const_closure<T: ~const FnOnce(()) -> i32>(x: T) -> i32 {
    |                                       ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-default-method-bodies.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-default-method-bodies.stderr
index 7b558e3f773..111a6a3fc7f 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-default-method-bodies.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-default-method-bodies.stderr
@@ -6,6 +6,6 @@ LL |     NonConstImpl.a();
    |
    = help: the trait `ConstDefaultFn` is implemented for `NonConstImpl`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-bound.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-bound.stderr
index f5147dc74b8..16ed615907b 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-bound.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-bound.stderr
@@ -4,6 +4,6 @@ error[E0493]: destructor of `E` cannot be evaluated at compile-time
 LL |         Err(_e) => None,
    |             ^^ the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail-2.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail-2.stderr
index 100d1df87d6..6f75924f0aa 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail-2.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail-2.stderr
@@ -6,6 +6,6 @@ LL | const fn check<T: ~const Destruct>(_: T) {}
    |                                    |
    |                                    the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr
index dfa5ea8c4af..8997e7ade6c 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr
@@ -4,6 +4,6 @@ error[E0493]: destructor of `T` cannot be evaluated at compile-time
 LL | const fn check<T: ~const Destruct>(_: T) {}
    |                                    ^ the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr
index 8af38b792e6..09ebf55c57c 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr
@@ -6,6 +6,6 @@ LL | const fn check<T: ~const Destruct>(_: T) {}
    |                                    |
    |                                    the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr
index be75e852e0a..5c0f19b5f14 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.precise.stderr
@@ -6,5 +6,5 @@ LL |     pub struct ConstDropWithBound<T: ~const SomeTrait>(pub core::marker::Ph
    |
    = note: this item cannot have `~const` trait bounds
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr
index be75e852e0a..5c0f19b5f14 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-drop.stock.stderr
@@ -6,5 +6,5 @@ LL |     pub struct ConstDropWithBound<T: ~const SomeTrait>(pub core::marker::Ph
    |
    = note: this item cannot have `~const` trait bounds
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-norecover.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-norecover.stderr
index 603f6b7d283..efa72463c5e 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-norecover.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-norecover.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found keyword `impl`
 LL | const impl Foo {
    |       ^^^^ expected identifier, found keyword
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-requires-const-trait.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-requires-const-trait.stderr
index c45af1a9f8a..f0b6e2b1c25 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-requires-const-trait.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const-impl-requires-const-trait.stderr
@@ -10,5 +10,5 @@ LL | impl const A for () {}
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-gate.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-gate.stderr
index cc9bdd2715f..2dd96f548fe 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-gate.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-gate.stderr
@@ -6,6 +6,6 @@ LL | #[derive_const(Default)]
    |
    = help: add `#![feature(derive_const)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-non-const-type.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-non-const-type.stderr
index 1c69ad43171..dfe8fa79e26 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-non-const-type.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-non-const-type.stderr
@@ -8,5 +8,5 @@ LL | #[derive_const(Default)]
    = note: adding a non-const method body in the future would be a breaking change
    = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr
index 37d123e4ccc..3a8c4833414 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr
@@ -6,5 +6,5 @@ LL | #[derive_const(PartialEq)]
    |
    = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.gatednc.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.gatednc.stderr
index 428286e0b12..ed647aee8c3 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.gatednc.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.gatednc.stderr
@@ -6,6 +6,6 @@ LL |     NonConst.func();
    |
    = help: the trait `cross_crate::MyTrait` is implemented for `cross_crate::NonConst`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.stock.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.stock.stderr
index 22f13a7416e..ab039397edc 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.stock.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate.stock.stderr
@@ -7,6 +7,6 @@ LL |     Const.func();
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/default-method-body-is-const-same-trait-ck.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/default-method-body-is-const-same-trait-ck.stderr
index a6881b8fed5..d8e2c0ffb81 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/default-method-body-is-const-same-trait-ck.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/default-method-body-is-const-same-trait-ck.stderr
@@ -6,6 +6,6 @@ LL |         ().a()
    |
    = help: the trait `Tr` is implemented for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.stderr
index 002d586ac64..413e217020d 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.stderr
@@ -6,6 +6,6 @@ LL |     (const || { (()).foo() })();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/feature-gate.gated.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/feature-gate.gated.stderr
index 4c630d33c55..663cdd1fe57 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/feature-gate.gated.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/feature-gate.gated.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/generic-bound.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/generic-bound.stderr
index 6a177592b64..1e8a70ffd29 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/generic-bound.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/generic-bound.stderr
@@ -11,6 +11,6 @@ LL | impl<T> const std::ops::Add for S<T> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/hir-const-check.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/hir-const-check.stderr
index 6d2be1daa37..90f30ea635f 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/hir-const-check.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/hir-const-check.stderr
@@ -7,6 +7,6 @@ LL |         Some(())?;
    = note: see issue #74935 <https://github.com/rust-lang/rust/issues/74935> for more information
    = help: add `#![feature(const_try)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-tilde-const-trait.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-tilde-const-trait.stderr
index 0a91719e1f1..4695728f8ca 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-tilde-const-trait.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-tilde-const-trait.stderr
@@ -4,5 +4,5 @@ error: expected a trait, found type
 LL | impl ~const T for S {}
    |      ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-with-default-fn-fail.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-with-default-fn-fail.stderr
index 6c6ca9f5db8..36c8163f1c5 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-with-default-fn-fail.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/impl-with-default-fn-fail.stderr
@@ -7,6 +7,6 @@ LL |     fn req(&self);
 LL | impl const Tr for u16 {
    | ^^^^^^^^^^^^^^^^^^^^^ missing `req` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-102985.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-102985.stderr
index f0c61cf9dd9..077f6c7b234 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-102985.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-102985.stderr
@@ -6,6 +6,6 @@ LL |         n => n(),
    |
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-79450.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-79450.stderr
index 082c0333fbf..85996c21211 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-79450.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-79450.stderr
@@ -7,6 +7,6 @@ LL |         println!("lul");
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-88155.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-88155.stderr
index d8cb10c6517..157b54214fa 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-88155.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-88155.stderr
@@ -6,6 +6,6 @@ LL |     T::assoc()
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-92111.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-92111.stderr
index b27f94f99ed..2edaca60623 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-92111.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/issue-92111.stderr
@@ -6,6 +6,6 @@ LL | const fn a<T: ~const Destruct>(t: T) {}
    |                                |
    |                                the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.gated.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.gated.stderr
index 4fe8a372e07..89e59e5db6e 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.gated.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.gated.stderr
@@ -7,6 +7,6 @@ LL |         "a" => (), //FIXME [gated]~ ERROR can't compare `str` with `str` in
    = note: `str` cannot be compared in compile-time, and therefore cannot be used in `match`es
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.stock.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.stock.stderr
index c36142dac92..5431116a1a7 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.stock.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.stock.stderr
@@ -8,6 +8,6 @@ LL |         "a" => (), //FIXME [gated]~ ERROR can't compare `str` with `str` in
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-const-closure-non-const-outer.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-const-closure-non-const-outer.stderr
index 979d7febbca..97ad83130d4 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-const-closure-non-const-outer.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-const-closure-non-const-outer.stderr
@@ -6,6 +6,6 @@ LL |     (const || { (()).foo() })();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-in-closure-in-const.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-in-closure-in-const.stderr
index cfdda4713a7..b2e09d82a90 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-in-closure-in-const.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-in-closure-in-const.stderr
@@ -4,5 +4,5 @@ error: ~const can only be applied to `#[const_trait]` traits
 LL | impl<A, B> const Convert<B> for A where B: ~const From<A> {
    |                                                   ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/const-default-impl-non-const-specialized-impl.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/const-default-impl-non-const-specialized-impl.stderr
index 24766804708..e356621ba47 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/const-default-impl-non-const-specialized-impl.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/const-default-impl-non-const-specialized-impl.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on const impl with non-const impl
 LL | impl Value for FortyTwo {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/non-const-default-const-specialized.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/non-const-default-const-specialized.stderr
index 4734cee7f9a..68eac990aaa 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/non-const-default-const-specialized.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/specialization/non-const-default-const-specialized.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Value for T {
 LL | impl const Value for FortyTwo {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `FortyTwo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness-2.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness-2.stderr
index 92bc9815e96..0b35feddc55 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness-2.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness-2.stderr
@@ -6,6 +6,6 @@ LL |     <T as A>::a();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness.stderr
index 08258fd1a57..21e21c2cb71 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on const impl with non-const impl
 LL | impl<T: Spec + Sup> A for T {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/staged-api-user-crate.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/staged-api-user-crate.stderr
index d7aa0d95cfc..1346c4c4ae2 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/staged-api-user-crate.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/staged-api-user-crate.stderr
@@ -7,6 +7,6 @@ LL |     Unstable::func();
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.gated.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.gated.stderr
index 78aab9469e8..bf53b995bb6 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.gated.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.gated.stderr
@@ -4,6 +4,6 @@ error[E0635]: unknown feature `const_default_impls`
 LL | #![cfg_attr(gated, feature(const_trait_impl, const_default_impls))]
    |                                              ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0635`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.stock.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.stock.stderr
index 6a3396401d2..6d624def276 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.stock.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/std-impl-gate.stock.stderr
@@ -7,6 +7,6 @@ LL |     Default::default()
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
index 06330958b8e..bb206d50b74 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
@@ -10,5 +10,5 @@ note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bou
 LL | trait Bar: ~const Foo {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yy.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yy.stderr
index 5d34156a519..1faa5b4dd2c 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yy.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yy.stderr
@@ -6,6 +6,6 @@ LL |     x.a();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yy.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yy.stderr
index d81d9aa94da..5cccc025161 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yy.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yy.stderr
@@ -6,6 +6,6 @@ LL |     x.a();
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-maybe-trait.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-maybe-trait.stderr
index ce74ff8dde7..5850ab41c6b 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-maybe-trait.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-const-maybe-trait.stderr
@@ -4,5 +4,5 @@ error: `~const` and `?` are mutually exclusive
 LL | const fn tilde_question<T: ~const ?Sized>() {}
    |                            ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-twice.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-twice.stderr
index 928d23e8a42..a809736a4f8 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-twice.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde-twice.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `~`
 LL | struct S<T: ~const ~const Tr>;
    |                    ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde_const_on_impl_bound.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde_const_on_impl_bound.stderr
index f77672f3e71..0925bfa7e57 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde_const_on_impl_bound.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/tilde_const_on_impl_bound.stderr
@@ -7,6 +7,6 @@ LL |         self.0.foo()
    = note: expected constant `host`
               found constant `true`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/without-tilde.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/without-tilde.stderr
index 31300354a57..646cdfc78f9 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/without-tilde.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/without-tilde.stderr
@@ -6,5 +6,5 @@ LL | struct S<T: const Tr>;
    |             |
    |             help: add `~`: `~`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rmeta/no_optitimized_mir.stderr b/tests/ui/rmeta/no_optitimized_mir.stderr
index a17024c5310..92f22d78000 100644
--- a/tests/ui/rmeta/no_optitimized_mir.stderr
+++ b/tests/ui/rmeta/no_optitimized_mir.stderr
@@ -6,5 +6,5 @@ note: missing optimized MIR for this item (was the crate `rmeta_meta` compiled w
 LL | pub fn missing_optimized_mir() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rmeta/rmeta.stderr b/tests/ui/rmeta/rmeta.stderr
index d15caeb6698..85452ea41d3 100644
--- a/tests/ui/rmeta/rmeta.stderr
+++ b/tests/ui/rmeta/rmeta.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `Foo` in this scope
 LL |     let _ = Foo;
    |             ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/rmeta/rmeta_lib.stderr b/tests/ui/rmeta/rmeta_lib.stderr
index 8a9179cca6b..830169e032a 100644
--- a/tests/ui/rmeta/rmeta_lib.stderr
+++ b/tests/ui/rmeta/rmeta_lib.stderr
@@ -1,4 +1,4 @@
 error: crate `rmeta_meta` required to be available in rlib format, but was not found in this form
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rmeta/rmeta_meta_main.stderr b/tests/ui/rmeta/rmeta_meta_main.stderr
index a4af319e339..af11c88d928 100644
--- a/tests/ui/rmeta/rmeta_meta_main.stderr
+++ b/tests/ui/rmeta/rmeta_meta_main.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |     let _ = Foo { field: 42 };
    |                   ~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/rust-2018/async-ident-allowed.stderr b/tests/ui/rust-2018/async-ident-allowed.stderr
index 992b2975009..b413c0fd9ba 100644
--- a/tests/ui/rust-2018/async-ident-allowed.stderr
+++ b/tests/ui/rust-2018/async-ident-allowed.stderr
@@ -13,5 +13,5 @@ LL | #![deny(rust_2018_compatibility)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
    = note: `#[deny(keyword_idents)]` implied by `#[deny(rust_2018_compatibility)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/dyn-keyword.stderr b/tests/ui/rust-2018/dyn-keyword.stderr
index b6f5b10cf03..6f9a5ddb14f 100644
--- a/tests/ui/rust-2018/dyn-keyword.stderr
+++ b/tests/ui/rust-2018/dyn-keyword.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(keyword_idents)]
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/extern-crate-idiomatic-in-2018.stderr b/tests/ui/rust-2018/extern-crate-idiomatic-in-2018.stderr
index bb50ec3f57d..a68d99c14ce 100644
--- a/tests/ui/rust-2018/extern-crate-idiomatic-in-2018.stderr
+++ b/tests/ui/rust-2018/extern-crate-idiomatic-in-2018.stderr
@@ -11,5 +11,5 @@ LL | #![deny(rust_2018_idioms)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(unused_extern_crates)]` implied by `#[deny(rust_2018_idioms)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/extern-crate-rename.stderr b/tests/ui/rust-2018/extern-crate-rename.stderr
index eb040f5de54..36986c89c62 100644
--- a/tests/ui/rust-2018/extern-crate-rename.stderr
+++ b/tests/ui/rust-2018/extern-crate-rename.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(absolute_paths_not_starting_with_crate)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/extern-crate-submod.stderr b/tests/ui/rust-2018/extern-crate-submod.stderr
index 1a9aa75787a..85e26d72a67 100644
--- a/tests/ui/rust-2018/extern-crate-submod.stderr
+++ b/tests/ui/rust-2018/extern-crate-submod.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(absolute_paths_not_starting_with_crate)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/issue-52202-use-suggestions.stderr b/tests/ui/rust-2018/issue-52202-use-suggestions.stderr
index 9933b92439c..49736205f20 100644
--- a/tests/ui/rust-2018/issue-52202-use-suggestions.stderr
+++ b/tests/ui/rust-2018/issue-52202-use-suggestions.stderr
@@ -16,6 +16,6 @@ LL + use std::collections::hash_set::Drain;
    |
      and 3 other candidates
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/rust-2018/issue-54400-unused-extern-crate-attr-span.stderr b/tests/ui/rust-2018/issue-54400-unused-extern-crate-attr-span.stderr
index 2ef97e7f20e..801d16af82d 100644
--- a/tests/ui/rust-2018/issue-54400-unused-extern-crate-attr-span.stderr
+++ b/tests/ui/rust-2018/issue-54400-unused-extern-crate-attr-span.stderr
@@ -14,5 +14,5 @@ LL | #![deny(rust_2018_idioms)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(unused_extern_crates)]` implied by `#[deny(rust_2018_idioms)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rust-2018/local-path-suggestions-2015.stderr b/tests/ui/rust-2018/local-path-suggestions-2015.stderr
index 666864a18af..e726b1e3e81 100644
--- a/tests/ui/rust-2018/local-path-suggestions-2015.stderr
+++ b/tests/ui/rust-2018/local-path-suggestions-2015.stderr
@@ -7,6 +7,6 @@ LL | use foobar::Baz;
    |     unresolved import
    |     help: a similar path exists: `aux_baz::foobar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr b/tests/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
index a5c79366bf0..f2536c1a1e9 100644
--- a/tests/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
+++ b/tests/ui/rust-2018/uniform-paths/ambiguity-macros-nested.stderr
@@ -20,6 +20,6 @@ LL |       m!();
    = help: use `self::std` to refer to this module unambiguously
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/rust-2018/uniform-paths/ambiguity-macros.stderr b/tests/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
index 8045f3a45b6..3400183df6f 100644
--- a/tests/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
+++ b/tests/ui/rust-2018/uniform-paths/ambiguity-macros.stderr
@@ -20,6 +20,6 @@ LL |   m!();
    = help: use `crate::std` to refer to this module unambiguously
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/rust-2018/uniform-paths/issue-54253.stderr b/tests/ui/rust-2018/uniform-paths/issue-54253.stderr
index adde6359035..7a1c55a8b2b 100644
--- a/tests/ui/rust-2018/uniform-paths/issue-54253.stderr
+++ b/tests/ui/rust-2018/uniform-paths/issue-54253.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `crate::version`
 LL |     use crate::version;
    |         ^^^^^^^^^^^^^^ no `version` in the root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rust-2018/uniform-paths/issue-56596.stderr b/tests/ui/rust-2018/uniform-paths/issue-56596.stderr
index 849d6275eb8..363d7a7a25f 100644
--- a/tests/ui/rust-2018/uniform-paths/issue-56596.stderr
+++ b/tests/ui/rust-2018/uniform-paths/issue-56596.stderr
@@ -15,6 +15,6 @@ LL | use m::*;
    = help: consider adding an explicit import of `issue_56596` to disambiguate
    = help: or use `crate::issue_56596` to refer to this module unambiguously
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/rust-2018/uniform-paths/issue-87932.stderr b/tests/ui/rust-2018/uniform-paths/issue-87932.stderr
index ac2baa3595b..4a874a834bb 100644
--- a/tests/ui/rust-2018/uniform-paths/issue-87932.stderr
+++ b/tests/ui/rust-2018/uniform-paths/issue-87932.stderr
@@ -13,6 +13,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use <crate::A as issue_87932_a::Deserialize>::deserialize::_a::Deserialize;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/rust-2018/uniform-paths/macro-rules.stderr b/tests/ui/rust-2018/uniform-paths/macro-rules.stderr
index 8a978c98a44..661d667eb9a 100644
--- a/tests/ui/rust-2018/uniform-paths/macro-rules.stderr
+++ b/tests/ui/rust-2018/uniform-paths/macro-rules.stderr
@@ -10,6 +10,6 @@ help: consider adding a `#[macro_export]` to the macro in the imported module
 LL |     macro_rules! legacy_macro { () => () }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0364`.
diff --git a/tests/ui/rust-2018/uniform-paths/prelude-fail.stderr b/tests/ui/rust-2018/uniform-paths/prelude-fail.stderr
index 97d4c736751..a0d272dc658 100644
--- a/tests/ui/rust-2018/uniform-paths/prelude-fail.stderr
+++ b/tests/ui/rust-2018/uniform-paths/prelude-fail.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `rustfmt`
 LL | use rustfmt::skip as imported_rustfmt_skip;
    |     ^^^^^^^ `rustfmt` is a tool module, not a module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rust-2018/unresolved-asterisk-imports.stderr b/tests/ui/rust-2018/unresolved-asterisk-imports.stderr
index 09e9edc638d..b6bf109824f 100644
--- a/tests/ui/rust-2018/unresolved-asterisk-imports.stderr
+++ b/tests/ui/rust-2018/unresolved-asterisk-imports.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `not_existing_crate`
 LL | use not_existing_crate::*;
    |     ^^^^^^^^^^^^^^^^^^ use of undeclared crate or module `not_existing_crate`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/rust-2021/future-prelude-collision-shadow.stderr b/tests/ui/rust-2021/future-prelude-collision-shadow.stderr
index 9dfaf13e2ec..d2b2e5b2fd7 100644
--- a/tests/ui/rust-2021/future-prelude-collision-shadow.stderr
+++ b/tests/ui/rust-2021/future-prelude-collision-shadow.stderr
@@ -13,6 +13,6 @@ LL +     use crate::m::TryIntoU32;
 LL +     use std::convert::TryInto;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/rustc-error.stderr b/tests/ui/rustc-error.stderr
index de27e9b8f08..67451195b64 100644
--- a/tests/ui/rustc-error.stderr
+++ b/tests/ui/rustc-error.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rustdoc/cfg-rustdoc.stderr b/tests/ui/rustdoc/cfg-rustdoc.stderr
index c687d186989..340a8e22482 100644
--- a/tests/ui/rustdoc/cfg-rustdoc.stderr
+++ b/tests/ui/rustdoc/cfg-rustdoc.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `Foo` in this scope
 LL |     let f = Foo;
    |             ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/rustdoc/deny-invalid-doc-attrs.stderr b/tests/ui/rustdoc/deny-invalid-doc-attrs.stderr
index e9a4c1dd52f..bf104f48be0 100644
--- a/tests/ui/rustdoc/deny-invalid-doc-attrs.stderr
+++ b/tests/ui/rustdoc/deny-invalid-doc-attrs.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(invalid_doc_attributes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rustdoc/doc-alias-same-name.stderr b/tests/ui/rustdoc/doc-alias-same-name.stderr
index 5ba09a2eae1..a9da75c0171 100644
--- a/tests/ui/rustdoc/doc-alias-same-name.stderr
+++ b/tests/ui/rustdoc/doc-alias-same-name.stderr
@@ -4,5 +4,5 @@ error: `#[doc(alias = "...")]` is the same as the item's name
 LL | #[doc(alias = "Foo")]
    |       ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rustdoc/doc-inline-extern-crate.stderr b/tests/ui/rustdoc/doc-inline-extern-crate.stderr
index 41518295b12..df0c4cb6b63 100644
--- a/tests/ui/rustdoc/doc-inline-extern-crate.stderr
+++ b/tests/ui/rustdoc/doc-inline-extern-crate.stderr
@@ -9,5 +9,5 @@ LL | #[doc(no_inline)]
    |
    = help: remove one of the conflicting attributes
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rustdoc/doc-primitive.stderr b/tests/ui/rustdoc/doc-primitive.stderr
index d61eb381647..5f535206d26 100644
--- a/tests/ui/rustdoc/doc-primitive.stderr
+++ b/tests/ui/rustdoc/doc-primitive.stderr
@@ -12,5 +12,5 @@ note: the lint level is defined here
 LL | #![deny(invalid_doc_attributes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rustdoc/feature-gate-doc_primitive.stderr b/tests/ui/rustdoc/feature-gate-doc_primitive.stderr
index 5920880675d..0f5665f1fb9 100644
--- a/tests/ui/rustdoc/feature-gate-doc_primitive.stderr
+++ b/tests/ui/rustdoc/feature-gate-doc_primitive.stderr
@@ -6,6 +6,6 @@ LL | #[rustc_doc_primitive = "usize"]
    |
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rustdoc/unterminated-doc-comment.stderr b/tests/ui/rustdoc/unterminated-doc-comment.stderr
index 2d5e537973e..2d96c606b16 100644
--- a/tests/ui/rustdoc/unterminated-doc-comment.stderr
+++ b/tests/ui/rustdoc/unterminated-doc-comment.stderr
@@ -4,6 +4,6 @@ error[E0758]: unterminated block doc-comment
 LL | /*!
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0758`.
diff --git a/tests/ui/sanitize/crt-static.stderr b/tests/ui/sanitize/crt-static.stderr
index 9f74235fea5..98b0ed82e80 100644
--- a/tests/ui/sanitize/crt-static.stderr
+++ b/tests/ui/sanitize/crt-static.stderr
@@ -1,4 +1,4 @@
 error: sanitizer is incompatible with statically linked libc, disable it using `-C target-feature=-crt-static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/incompatible.stderr b/tests/ui/sanitize/incompatible.stderr
index f86db41bac7..4dff813ee1b 100644
--- a/tests/ui/sanitize/incompatible.stderr
+++ b/tests/ui/sanitize/incompatible.stderr
@@ -1,4 +1,4 @@
 error: `-Zsanitizer=address` is incompatible with `-Zsanitizer=memory`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/sanitizer-cfi-canonical-jump-tables-require-cfi.stderr b/tests/ui/sanitize/sanitizer-cfi-canonical-jump-tables-require-cfi.stderr
index 3ee95634b16..de67d6a6b7f 100644
--- a/tests/ui/sanitize/sanitizer-cfi-canonical-jump-tables-require-cfi.stderr
+++ b/tests/ui/sanitize/sanitizer-cfi-canonical-jump-tables-require-cfi.stderr
@@ -1,4 +1,4 @@
 error: `-Zsanitizer-cfi-canonical-jump-tables` requires `-Zsanitizer=cfi`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/sanitizer-cfi-generalize-pointers-require-cfi.stderr b/tests/ui/sanitize/sanitizer-cfi-generalize-pointers-require-cfi.stderr
index 6eb09a53b48..621708de241 100644
--- a/tests/ui/sanitize/sanitizer-cfi-generalize-pointers-require-cfi.stderr
+++ b/tests/ui/sanitize/sanitizer-cfi-generalize-pointers-require-cfi.stderr
@@ -1,4 +1,4 @@
 error: `-Zsanitizer-cfi-generalize-pointers` requires `-Zsanitizer=cfi` or `-Zsanitizer=kcfi`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/sanitizer-cfi-invalid-attr-cfi-encoding.stderr b/tests/ui/sanitize/sanitizer-cfi-invalid-attr-cfi-encoding.stderr
index e23bafb1814..b9e9722da23 100644
--- a/tests/ui/sanitize/sanitizer-cfi-invalid-attr-cfi-encoding.stderr
+++ b/tests/ui/sanitize/sanitizer-cfi-invalid-attr-cfi-encoding.stderr
@@ -4,5 +4,5 @@ error: malformed `cfi_encoding` attribute input
 LL | #[cfi_encoding]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[cfi_encoding = "encoding"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/sanitizer-cfi-normalize-integers-require-cfi.stderr b/tests/ui/sanitize/sanitizer-cfi-normalize-integers-require-cfi.stderr
index e3164205434..748fb60dad9 100644
--- a/tests/ui/sanitize/sanitizer-cfi-normalize-integers-require-cfi.stderr
+++ b/tests/ui/sanitize/sanitizer-cfi-normalize-integers-require-cfi.stderr
@@ -1,4 +1,4 @@
 error: `-Zsanitizer-cfi-normalize-integers` requires `-Zsanitizer=cfi` or `-Zsanitizer=kcfi`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/sanitizer-cfi-requires-lto.stderr b/tests/ui/sanitize/sanitizer-cfi-requires-lto.stderr
index 8cd9c544417..efc0c43138e 100644
--- a/tests/ui/sanitize/sanitizer-cfi-requires-lto.stderr
+++ b/tests/ui/sanitize/sanitizer-cfi-requires-lto.stderr
@@ -1,4 +1,4 @@
 error: `-Zsanitizer=cfi` requires `-Clto` or `-Clinker-plugin-lto`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/sanitizer-cfi-with-rustc-lto-requires-single-codegen-unit.stderr b/tests/ui/sanitize/sanitizer-cfi-with-rustc-lto-requires-single-codegen-unit.stderr
index 136f4936084..8d6dc1d8f1e 100644
--- a/tests/ui/sanitize/sanitizer-cfi-with-rustc-lto-requires-single-codegen-unit.stderr
+++ b/tests/ui/sanitize/sanitizer-cfi-with-rustc-lto-requires-single-codegen-unit.stderr
@@ -1,4 +1,4 @@
 error: `-Zsanitizer=cfi` with `-Clto` requires `-Ccodegen-units=1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/split-lto-unit-requires-lto.stderr b/tests/ui/sanitize/split-lto-unit-requires-lto.stderr
index ab8f4f4f351..0da06b7f8b1 100644
--- a/tests/ui/sanitize/split-lto-unit-requires-lto.stderr
+++ b/tests/ui/sanitize/split-lto-unit-requires-lto.stderr
@@ -1,4 +1,4 @@
 error: `-Zsplit-lto-unit` requires `-Clto`, `-Clto=thin`, or `-Clinker-plugin-lto`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sanitize/unsupported-target.stderr b/tests/ui/sanitize/unsupported-target.stderr
index 9bb8405020d..bebbf3884ae 100644
--- a/tests/ui/sanitize/unsupported-target.stderr
+++ b/tests/ui/sanitize/unsupported-target.stderr
@@ -1,4 +1,4 @@
 error: leak sanitizer is not supported for this target
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/self/arbitrary-self-from-method-substs.default.stderr b/tests/ui/self/arbitrary-self-from-method-substs.default.stderr
index cbf5e6c541a..a415aa3d7b4 100644
--- a/tests/ui/self/arbitrary-self-from-method-substs.default.stderr
+++ b/tests/ui/self/arbitrary-self-from-method-substs.default.stderr
@@ -8,6 +8,6 @@ LL |     fn get<R: Deref<Target = Self>>(self: R) -> u32 {
    = help: add `#![feature(arbitrary_self_types)]` to the crate attributes to enable
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/self/arbitrary-self-from-method-substs.feature.stderr b/tests/ui/self/arbitrary-self-from-method-substs.feature.stderr
index 7378d53c373..44e553f1a06 100644
--- a/tests/ui/self/arbitrary-self-from-method-substs.feature.stderr
+++ b/tests/ui/self/arbitrary-self-from-method-substs.feature.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     foo.get::<&Foo>();
    |     ^^^ expected `&Foo`, found `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/self/arbitrary-self-types-not-object-safe.object_safe_for_dispatch.stderr b/tests/ui/self/arbitrary-self-types-not-object-safe.object_safe_for_dispatch.stderr
index 0a567ddcc2e..363ba072c81 100644
--- a/tests/ui/self/arbitrary-self-types-not-object-safe.object_safe_for_dispatch.stderr
+++ b/tests/ui/self/arbitrary-self-types-not-object-safe.object_safe_for_dispatch.stderr
@@ -17,6 +17,6 @@ LL |     fn foo(self: &Rc<Self>) -> usize;
    = help: only type `usize` implements the trait, consider using it directly instead
    = note: required for the cast from `Rc<usize>` to `Rc<dyn Foo>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/self/arbitrary_self_types_needing_mut_pin.stderr b/tests/ui/self/arbitrary_self_types_needing_mut_pin.stderr
index 5dcb5861120..f33b9ec68b9 100644
--- a/tests/ui/self/arbitrary_self_types_needing_mut_pin.stderr
+++ b/tests/ui/self/arbitrary_self_types_needing_mut_pin.stderr
@@ -13,6 +13,6 @@ LL ~     let mut pinned = std::pin::pin!(S);
 LL ~     pinned.as_mut().x();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr b/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
index 944cdc5f55d..e04ec8bb3bc 100644
--- a/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
+++ b/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
@@ -12,6 +12,6 @@ help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` l
 LL |     async fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
    |                                                ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait.stderr b/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait.stderr
index 8a9b397ca70..a2964881d58 100644
--- a/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait.stderr
+++ b/tests/ui/self/arbitrary_self_types_pin_lifetime_impl_trait.stderr
@@ -12,6 +12,6 @@ help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` l
 LL |     fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
    |                                          ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/self/issue-61882-2.stderr b/tests/ui/self/issue-61882-2.stderr
index 6faa4477d8c..7d5214421e3 100644
--- a/tests/ui/self/issue-61882-2.stderr
+++ b/tests/ui/self/issue-61882-2.stderr
@@ -12,6 +12,6 @@ LL |
 LL |     }
    |     - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/self/point-at-arbitrary-self-type-method.stderr b/tests/ui/self/point-at-arbitrary-self-type-method.stderr
index 3c7cccfc9a1..14bd6ca6b01 100644
--- a/tests/ui/self/point-at-arbitrary-self-type-method.stderr
+++ b/tests/ui/self/point-at-arbitrary-self-type-method.stderr
@@ -15,6 +15,6 @@ help: consider wrapping the receiver expression with the appropriate type
 LL |     Box::new(A).foo();
    |     +++++++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/self/point-at-arbitrary-self-type-trait-method.stderr b/tests/ui/self/point-at-arbitrary-self-type-trait-method.stderr
index 366c14f7616..29510190c81 100644
--- a/tests/ui/self/point-at-arbitrary-self-type-trait-method.stderr
+++ b/tests/ui/self/point-at-arbitrary-self-type-trait-method.stderr
@@ -16,6 +16,6 @@ help: consider wrapping the receiver expression with the appropriate type
 LL |     Box::new(A).foo()
    |     +++++++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/self/self-vs-path-ambiguity.stderr b/tests/ui/self/self-vs-path-ambiguity.stderr
index 2beef50cdb5..9e140e21023 100644
--- a/tests/ui/self/self-vs-path-ambiguity.stderr
+++ b/tests/ui/self/self-vs-path-ambiguity.stderr
@@ -4,5 +4,5 @@ error: unexpected lifetime `'a` in pattern
 LL |     fn i(&'a self::S: &S) {}
    |           ^^ help: remove the lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/shadowed/shadowed-trait-methods.stderr b/tests/ui/shadowed/shadowed-trait-methods.stderr
index 1af0400c886..0bcf32790bc 100644
--- a/tests/ui/shadowed/shadowed-trait-methods.stderr
+++ b/tests/ui/shadowed/shadowed-trait-methods.stderr
@@ -13,6 +13,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use foo::T;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/simd/monomorphize-heterogeneous.stderr b/tests/ui/simd/monomorphize-heterogeneous.stderr
index e7b41cd787c..58e2b7c8347 100644
--- a/tests/ui/simd/monomorphize-heterogeneous.stderr
+++ b/tests/ui/simd/monomorphize-heterogeneous.stderr
@@ -4,6 +4,6 @@ error[E0076]: SIMD vector should be homogeneous
 LL | struct I64F64(i64, f64);
    | ^^^^^^^^^^^^^ SIMD elements must have the same type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0076`.
diff --git a/tests/ui/simd/monomorphize-shuffle-index.generic.stderr b/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
index fc66b195674..c4cfca7be1d 100644
--- a/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
+++ b/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
@@ -8,5 +8,5 @@ LL |         return simd_shuffle_generic::<_, _, { &Self::I }>(a, b);
    |
    = help: consider moving this anonymous constant into a `const` function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-generic-monomorphisation-empty.stderr b/tests/ui/simd/type-generic-monomorphisation-empty.stderr
index b334b1f4b58..fc294607ae3 100644
--- a/tests/ui/simd/type-generic-monomorphisation-empty.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation-empty.stderr
@@ -1,4 +1,4 @@
 error: monomorphising SIMD type `Simd<0>` of zero length
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-generic-monomorphisation-non-primitive.stderr b/tests/ui/simd/type-generic-monomorphisation-non-primitive.stderr
index 9e8f06b824c..249a14098c3 100644
--- a/tests/ui/simd/type-generic-monomorphisation-non-primitive.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation-non-primitive.stderr
@@ -1,4 +1,4 @@
 error: monomorphising SIMD type `S<E>` with a non-primitive-scalar (integer/float/pointer) element type `E`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-generic-monomorphisation-oversized.stderr b/tests/ui/simd/type-generic-monomorphisation-oversized.stderr
index a2dba1222ee..39ff36799cc 100644
--- a/tests/ui/simd/type-generic-monomorphisation-oversized.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation-oversized.stderr
@@ -1,4 +1,4 @@
 error: monomorphising SIMD type `Simd<65536>` of length greater than 32768
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-generic-monomorphisation-wide-ptr.stderr b/tests/ui/simd/type-generic-monomorphisation-wide-ptr.stderr
index 3888e7a0f38..7ac8d715360 100644
--- a/tests/ui/simd/type-generic-monomorphisation-wide-ptr.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation-wide-ptr.stderr
@@ -1,4 +1,4 @@
 error: monomorphising SIMD type `S<[*mut [u8]; 4]>` with a non-primitive-scalar (integer/float/pointer) element type `*mut [u8]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-generic-monomorphisation.stderr b/tests/ui/simd/type-generic-monomorphisation.stderr
index 7f23893ac85..35297e17d37 100644
--- a/tests/ui/simd/type-generic-monomorphisation.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation.stderr
@@ -1,4 +1,4 @@
 error: monomorphising SIMD type `Simd2<X>` with a non-primitive-scalar (integer/float/pointer) element type `X`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-wide-ptr.stderr b/tests/ui/simd/type-wide-ptr.stderr
index 51d3c005072..d2ce0fdd202 100644
--- a/tests/ui/simd/type-wide-ptr.stderr
+++ b/tests/ui/simd/type-wide-ptr.stderr
@@ -1,4 +1,4 @@
 error: monomorphising SIMD type `S` with a non-primitive-scalar (integer/float/pointer) element type `*mut [u8]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/single-use-lifetime/one-use-in-inherent-impl-header.stderr b/tests/ui/single-use-lifetime/one-use-in-inherent-impl-header.stderr
index 94129560f40..e151269d731 100644
--- a/tests/ui/single-use-lifetime/one-use-in-inherent-impl-header.stderr
+++ b/tests/ui/single-use-lifetime/one-use-in-inherent-impl-header.stderr
@@ -17,5 +17,5 @@ LL - impl<'f> Foo<'f> {
 LL + impl Foo<'_> {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/single-use-lifetime/one-use-in-inherent-method-return.stderr b/tests/ui/single-use-lifetime/one-use-in-inherent-method-return.stderr
index 69578fe2f88..bc86e36f308 100644
--- a/tests/ui/single-use-lifetime/one-use-in-inherent-method-return.stderr
+++ b/tests/ui/single-use-lifetime/one-use-in-inherent-method-return.stderr
@@ -17,5 +17,5 @@ LL - impl<'f> Foo<'f> {
 LL + impl Foo<'_> {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/single-use-lifetime/one-use-in-trait-method-argument.stderr b/tests/ui/single-use-lifetime/one-use-in-trait-method-argument.stderr
index 1a6e8310d30..0e67180a8ee 100644
--- a/tests/ui/single-use-lifetime/one-use-in-trait-method-argument.stderr
+++ b/tests/ui/single-use-lifetime/one-use-in-trait-method-argument.stderr
@@ -17,5 +17,5 @@ LL -     fn next<'g>(&'g mut self) -> Option<Self::Item> {
 LL +     fn next(&mut self) -> Option<Self::Item> {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/single-use-lifetime/two-uses-in-inherent-method-argument-and-return.stderr b/tests/ui/single-use-lifetime/two-uses-in-inherent-method-argument-and-return.stderr
index 4794566eae4..4cc46524a92 100644
--- a/tests/ui/single-use-lifetime/two-uses-in-inherent-method-argument-and-return.stderr
+++ b/tests/ui/single-use-lifetime/two-uses-in-inherent-method-argument-and-return.stderr
@@ -17,5 +17,5 @@ LL - impl<'f> Foo<'f> {
 LL + impl Foo<'_> {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/single-use-lifetime/zero-uses-in-impl.stderr b/tests/ui/single-use-lifetime/zero-uses-in-impl.stderr
index b6e42d3e717..554a19afbcd 100644
--- a/tests/ui/single-use-lifetime/zero-uses-in-impl.stderr
+++ b/tests/ui/single-use-lifetime/zero-uses-in-impl.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_lifetimes)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sized-cycle-note.stderr b/tests/ui/sized-cycle-note.stderr
index 06c87b61f41..21e54c12fed 100644
--- a/tests/ui/sized-cycle-note.stderr
+++ b/tests/ui/sized-cycle-note.stderr
@@ -14,6 +14,6 @@ LL |
 LL ~ struct Foo { q: Option<Box<Baz>> }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/sized/recursive-type-2.stderr b/tests/ui/sized/recursive-type-2.stderr
index 0f72f74145e..4e7f40a0153 100644
--- a/tests/ui/sized/recursive-type-2.stderr
+++ b/tests/ui/sized/recursive-type-2.stderr
@@ -9,6 +9,6 @@ LL | fn main() {
    | ^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/sized/unsized-binding.stderr b/tests/ui/sized/unsized-binding.stderr
index af306685021..7c3276032c2 100644
--- a/tests/ui/sized/unsized-binding.stderr
+++ b/tests/ui/sized/unsized-binding.stderr
@@ -8,6 +8,6 @@ LL |     let x = *"";
    = note: all local variables must have a statically known size
    = help: unsized locals are gated as an unstable feature
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/span/E0046.stderr b/tests/ui/span/E0046.stderr
index 1323524f208..416873a4257 100644
--- a/tests/ui/span/E0046.stderr
+++ b/tests/ui/span/E0046.stderr
@@ -7,6 +7,6 @@ LL |     fn foo();
 LL | impl Foo for Bar {}
    | ^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/span/E0072.stderr b/tests/ui/span/E0072.stderr
index 20f2e0df05e..c8599b4ebe5 100644
--- a/tests/ui/span/E0072.stderr
+++ b/tests/ui/span/E0072.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     tail: Option<Box<ListNode>>,
    |                  ++++        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/span/E0493.stderr b/tests/ui/span/E0493.stderr
index 9db627562d6..0f2e2d7b3fb 100644
--- a/tests/ui/span/E0493.stderr
+++ b/tests/ui/span/E0493.stderr
@@ -6,6 +6,6 @@ LL | const F : Foo = (Foo { a : 0 }, Foo { a : 1 }).1;
    |                 |
    |                 the destructor for this type cannot be evaluated in constants
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/span/E0535.stderr b/tests/ui/span/E0535.stderr
index b1411bc436a..9060b687f50 100644
--- a/tests/ui/span/E0535.stderr
+++ b/tests/ui/span/E0535.stderr
@@ -6,6 +6,6 @@ LL | #[inline(unknown)]
    |
    = help: valid inline arguments are `always` and `never`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0535`.
diff --git a/tests/ui/span/E0536.stderr b/tests/ui/span/E0536.stderr
index 820b0d7441b..b0f652208c4 100644
--- a/tests/ui/span/E0536.stderr
+++ b/tests/ui/span/E0536.stderr
@@ -4,6 +4,6 @@ error[E0536]: expected 1 cfg-pattern
 LL | #[cfg(not())]
    |       ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0536`.
diff --git a/tests/ui/span/E0537.stderr b/tests/ui/span/E0537.stderr
index 5478c3fbcdd..4254d3893b8 100644
--- a/tests/ui/span/E0537.stderr
+++ b/tests/ui/span/E0537.stderr
@@ -4,6 +4,6 @@ error[E0537]: invalid predicate `unknown`
 LL | #[cfg(unknown())]
    |       ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0537`.
diff --git a/tests/ui/span/borrowck-call-method-from-mut-aliasable.stderr b/tests/ui/span/borrowck-call-method-from-mut-aliasable.stderr
index 3f033f5e47b..39e7279fb77 100644
--- a/tests/ui/span/borrowck-call-method-from-mut-aliasable.stderr
+++ b/tests/ui/span/borrowck-call-method-from-mut-aliasable.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL | fn b(x: &mut Foo) {
    |          +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/span/borrowck-fn-in-const-b.stderr b/tests/ui/span/borrowck-fn-in-const-b.stderr
index 92987802629..d4a8ba2698d 100644
--- a/tests/ui/span/borrowck-fn-in-const-b.stderr
+++ b/tests/ui/span/borrowck-fn-in-const-b.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be a mutable reference
 LL |     fn broken(x: &mut Vec<String>) {
    |                   +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/span/borrowck-ref-into-rvalue.stderr b/tests/ui/span/borrowck-ref-into-rvalue.stderr
index 25e344fedfb..c0edeeae20b 100644
--- a/tests/ui/span/borrowck-ref-into-rvalue.stderr
+++ b/tests/ui/span/borrowck-ref-into-rvalue.stderr
@@ -15,6 +15,6 @@ LL ~     let binding = Some("Hello".to_string());
 LL ~     match binding {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/span/destructor-restrictions.stderr b/tests/ui/span/destructor-restrictions.stderr
index b923cee5f0e..a80a89fb632 100644
--- a/tests/ui/span/destructor-restrictions.stderr
+++ b/tests/ui/span/destructor-restrictions.stderr
@@ -20,6 +20,6 @@ help: for example, you could save the expression's value in a new local variable
 LL |         let x = *a.borrow() + 1; x
    |         +++++++                +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-93117.stderr b/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-93117.stderr
index 1ec8ca4275b..004a057bbcd 100644
--- a/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-93117.stderr
+++ b/tests/ui/span/drop-location-span-error-rust-2021-incompatible-closure-captures-93117.stderr
@@ -4,5 +4,5 @@ error: this file contains an unclosed delimiter
 LL | trait C{async fn new(val: T) {}
    |        - unclosed delimiter                                                         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/span/dropck-object-cycle.stderr b/tests/ui/span/dropck-object-cycle.stderr
index 097fb6219f1..6e05f901ab2 100644
--- a/tests/ui/span/dropck-object-cycle.stderr
+++ b/tests/ui/span/dropck-object-cycle.stderr
@@ -12,6 +12,6 @@ LL | }
    | `*m` dropped here while still borrowed
    | borrow might be used here, when `m` is dropped and runs the destructor for type `Box<dyn Trait<'_>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/gated-features-attr-spans.stderr b/tests/ui/span/gated-features-attr-spans.stderr
index c8b8f346b98..5376d7799aa 100644
--- a/tests/ui/span/gated-features-attr-spans.stderr
+++ b/tests/ui/span/gated-features-attr-spans.stderr
@@ -7,6 +7,6 @@ LL | #[repr(simd)]
    = note: see issue #27731 <https://github.com/rust-lang/rust/issues/27731> for more information
    = help: add `#![feature(repr_simd)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/span/issue-11925.stderr b/tests/ui/span/issue-11925.stderr
index 1d317fc331f..c7f9573593b 100644
--- a/tests/ui/span/issue-11925.stderr
+++ b/tests/ui/span/issue-11925.stderr
@@ -4,6 +4,6 @@ error[E0515]: cannot return reference to local data `x`
 LL |         let f = to_fn_once(move|| &x);
    |                                   ^^ returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/span/issue-15480.stderr b/tests/ui/span/issue-15480.stderr
index d9cce2254dd..45a5d7dfbec 100644
--- a/tests/ui/span/issue-15480.stderr
+++ b/tests/ui/span/issue-15480.stderr
@@ -16,6 +16,6 @@ LL ~     let v = vec![
 LL ~         &binding
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/span/issue-23729.stderr b/tests/ui/span/issue-23729.stderr
index cd854e61f2f..6baec60d50c 100644
--- a/tests/ui/span/issue-23729.stderr
+++ b/tests/ui/span/issue-23729.stderr
@@ -6,6 +6,6 @@ LL |         impl Iterator for Recurrence {
    |
    = help: implement the missing item: `type Item = /* Type */;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/span/issue-23827.stderr b/tests/ui/span/issue-23827.stderr
index 83a9e8c9b98..fe7c7794c9c 100644
--- a/tests/ui/span/issue-23827.stderr
+++ b/tests/ui/span/issue-23827.stderr
@@ -6,6 +6,6 @@ LL | impl<C: Component> FnOnce<(C,)> for Prototype {
    |
    = help: implement the missing item: `type Output = /* Type */;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/span/issue-24356.stderr b/tests/ui/span/issue-24356.stderr
index cf666e8b4a7..609991f2b5b 100644
--- a/tests/ui/span/issue-24356.stderr
+++ b/tests/ui/span/issue-24356.stderr
@@ -6,6 +6,6 @@ LL |         impl Deref for Thing {
    |
    = help: implement the missing item: `type Target = /* Type */;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/span/issue-24805-dropck-child-has-items-via-parent.stderr b/tests/ui/span/issue-24805-dropck-child-has-items-via-parent.stderr
index c3b6d7580b4..f7564f8c72e 100644
--- a/tests/ui/span/issue-24805-dropck-child-has-items-via-parent.stderr
+++ b/tests/ui/span/issue-24805-dropck-child-has-items-via-parent.stderr
@@ -15,6 +15,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue-24895-copy-clone-dropck.stderr b/tests/ui/span/issue-24895-copy-clone-dropck.stderr
index 83db4d509d4..2252a241b73 100644
--- a/tests/ui/span/issue-24895-copy-clone-dropck.stderr
+++ b/tests/ui/span/issue-24895-copy-clone-dropck.stderr
@@ -14,6 +14,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue-25199.stderr b/tests/ui/span/issue-25199.stderr
index 1e0276f0c36..7a6910065fc 100644
--- a/tests/ui/span/issue-25199.stderr
+++ b/tests/ui/span/issue-25199.stderr
@@ -12,6 +12,6 @@ LL | }
    | `container` dropped here while still borrowed
    | borrow might be used here, when `container` is dropped and runs the destructor for type `Container<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue-26656.stderr b/tests/ui/span/issue-26656.stderr
index fea6e001238..586eca25473 100644
--- a/tests/ui/span/issue-26656.stderr
+++ b/tests/ui/span/issue-26656.stderr
@@ -14,6 +14,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue-27522.stderr b/tests/ui/span/issue-27522.stderr
index 8a254a96855..c2de1562841 100644
--- a/tests/ui/span/issue-27522.stderr
+++ b/tests/ui/span/issue-27522.stderr
@@ -7,6 +7,6 @@ LL |     fn handler(self: &SomeType);
    = note: type of `self` must be `Self` or a type that dereferences to it
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0307`.
diff --git a/tests/ui/span/issue-29595.stderr b/tests/ui/span/issue-29595.stderr
index 7d603cdbfe5..c7828754690 100644
--- a/tests/ui/span/issue-29595.stderr
+++ b/tests/ui/span/issue-29595.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Tr {
    | ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/span/issue-33884.stderr b/tests/ui/span/issue-33884.stderr
index 8cece07cd48..29490d86fff 100644
--- a/tests/ui/span/issue-33884.stderr
+++ b/tests/ui/span/issue-33884.stderr
@@ -6,6 +6,6 @@ LL |     stream.write_fmt(format!("message received"))
    |
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/span/issue-35987.stderr b/tests/ui/span/issue-35987.stderr
index 88c86d2a91b..4c4b100da3d 100644
--- a/tests/ui/span/issue-35987.stderr
+++ b/tests/ui/span/issue-35987.stderr
@@ -14,6 +14,6 @@ help: consider importing this trait instead
 LL + use std::ops::Add;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/span/issue-36537.stderr b/tests/ui/span/issue-36537.stderr
index 8dfee8d644b..eeb4e9a0e4f 100644
--- a/tests/ui/span/issue-36537.stderr
+++ b/tests/ui/span/issue-36537.stderr
@@ -11,6 +11,6 @@ LL |     }
 LL |     p.use_ref();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue-40157.stderr b/tests/ui/span/issue-40157.stderr
index 2168767178d..7b2ce292cfc 100644
--- a/tests/ui/span/issue-40157.stderr
+++ b/tests/ui/span/issue-40157.stderr
@@ -7,6 +7,6 @@ LL |     {println!("{:?}", match { let foo = vec![1, 2]; foo.get(1) } { x => x }
    |                                   |                 borrowed value does not live long enough
    |                                   binding `foo` declared here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue28498-reject-ex1.stderr b/tests/ui/span/issue28498-reject-ex1.stderr
index 86e2d8c56b0..7b8af23a6cd 100644
--- a/tests/ui/span/issue28498-reject-ex1.stderr
+++ b/tests/ui/span/issue28498-reject-ex1.stderr
@@ -12,6 +12,6 @@ LL | }
    |
    = note: consider using a `let` binding to create a longer lived value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0713`.
diff --git a/tests/ui/span/issue28498-reject-lifetime-param.stderr b/tests/ui/span/issue28498-reject-lifetime-param.stderr
index 94c450c7b1e..4b66dc76c44 100644
--- a/tests/ui/span/issue28498-reject-lifetime-param.stderr
+++ b/tests/ui/span/issue28498-reject-lifetime-param.stderr
@@ -15,6 +15,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue28498-reject-passed-to-fn.stderr b/tests/ui/span/issue28498-reject-passed-to-fn.stderr
index e133f75d57b..fe43657bd40 100644
--- a/tests/ui/span/issue28498-reject-passed-to-fn.stderr
+++ b/tests/ui/span/issue28498-reject-passed-to-fn.stderr
@@ -15,6 +15,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/issue28498-reject-trait-bound.stderr b/tests/ui/span/issue28498-reject-trait-bound.stderr
index 9ab3cdd1343..aafa29e5eae 100644
--- a/tests/ui/span/issue28498-reject-trait-bound.stderr
+++ b/tests/ui/span/issue28498-reject-trait-bound.stderr
@@ -15,6 +15,6 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/move-closure.stderr b/tests/ui/span/move-closure.stderr
index 2127b820205..2e9cef32e7e 100644
--- a/tests/ui/span/move-closure.stderr
+++ b/tests/ui/span/move-closure.stderr
@@ -13,6 +13,6 @@ help: use parentheses to call this closure
 LL |     let x: () = (move || ())();
    |                 +          +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/span/multiline-span-E0072.stderr b/tests/ui/span/multiline-span-E0072.stderr
index fc2f6e6622c..9e675d56ee5 100644
--- a/tests/ui/span/multiline-span-E0072.stderr
+++ b/tests/ui/span/multiline-span-E0072.stderr
@@ -13,6 +13,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     tail: Option<Box<ListNode>>,
    |                  ++++        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/span/multiline-span-simple.stderr b/tests/ui/span/multiline-span-simple.stderr
index b6052a209bf..f0eec632aa1 100644
--- a/tests/ui/span/multiline-span-simple.stderr
+++ b/tests/ui/span/multiline-span-simple.stderr
@@ -11,6 +11,6 @@ LL |     foo(1 as u32 +
              <&'a u32 as Add<u32>>
              <&u32 as Add<&u32>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/span/mut-ptr-cant-outlive-ref.stderr b/tests/ui/span/mut-ptr-cant-outlive-ref.stderr
index 395b6ec6791..1624b80e722 100644
--- a/tests/ui/span/mut-ptr-cant-outlive-ref.stderr
+++ b/tests/ui/span/mut-ptr-cant-outlive-ref.stderr
@@ -11,6 +11,6 @@ LL |
 LL |     p.use_ref();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/non-existing-module-import.stderr b/tests/ui/span/non-existing-module-import.stderr
index 25c09959047..7da9e32b31f 100644
--- a/tests/ui/span/non-existing-module-import.stderr
+++ b/tests/ui/span/non-existing-module-import.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `std::bar`
 LL | use std::bar::{foo1, foo2};
    |          ^^^ could not find `bar` in `std`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/span/recursive-type-field.stderr b/tests/ui/span/recursive-type-field.stderr
index 10af4c36ba4..30ba8cde463 100644
--- a/tests/ui/span/recursive-type-field.stderr
+++ b/tests/ui/span/recursive-type-field.stderr
@@ -22,6 +22,6 @@ LL | struct Bar<'a> {
 LL ~     y: (Box<Foo<'a>>, Box<Foo<'a>>),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/span/regionck-unboxed-closure-lifetimes.stderr b/tests/ui/span/regionck-unboxed-closure-lifetimes.stderr
index 9b5ec84614c..225f83b6e66 100644
--- a/tests/ui/span/regionck-unboxed-closure-lifetimes.stderr
+++ b/tests/ui/span/regionck-unboxed-closure-lifetimes.stderr
@@ -11,6 +11,6 @@ LL |     }
 LL |     f.use_mut();
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/regions-close-over-borrowed-ref-in-obj.stderr b/tests/ui/span/regions-close-over-borrowed-ref-in-obj.stderr
index 81e858fa0ce..b7ca491f22c 100644
--- a/tests/ui/span/regions-close-over-borrowed-ref-in-obj.stderr
+++ b/tests/ui/span/regions-close-over-borrowed-ref-in-obj.stderr
@@ -11,6 +11,6 @@ LL | }
    |
    = note: consider using a `let` binding to create a longer lived value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/span/regions-close-over-type-parameter-2.stderr b/tests/ui/span/regions-close-over-type-parameter-2.stderr
index fed40a4fdd2..3849b9eef08 100644
--- a/tests/ui/span/regions-close-over-type-parameter-2.stderr
+++ b/tests/ui/span/regions-close-over-type-parameter-2.stderr
@@ -10,6 +10,6 @@ LL |         repeater3(tmp1)
 LL |     };
    |     - `tmp0` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/regions-escape-loop-via-variable.stderr b/tests/ui/span/regions-escape-loop-via-variable.stderr
index e5c7d8b26ab..e32cc10c00c 100644
--- a/tests/ui/span/regions-escape-loop-via-variable.stderr
+++ b/tests/ui/span/regions-escape-loop-via-variable.stderr
@@ -10,6 +10,6 @@ LL |         p = &x;
 LL |     }
    |     - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/regions-infer-borrow-scope-within-loop.stderr b/tests/ui/span/regions-infer-borrow-scope-within-loop.stderr
index 47931db84ca..746be045608 100644
--- a/tests/ui/span/regions-infer-borrow-scope-within-loop.stderr
+++ b/tests/ui/span/regions-infer-borrow-scope-within-loop.stderr
@@ -12,6 +12,6 @@ LL |     }
 LL |     assert!(*y != 0);
    |             -- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/span/slice-borrow.stderr b/tests/ui/span/slice-borrow.stderr
index b271c9ae6f6..48ac20feea7 100644
--- a/tests/ui/span/slice-borrow.stderr
+++ b/tests/ui/span/slice-borrow.stderr
@@ -12,6 +12,6 @@ LL |     y.use_ref();
    = note: consider using a `let` binding to create a longer lived value
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/span/suggestion-non-ascii.stderr b/tests/ui/span/suggestion-non-ascii.stderr
index 21f8bb62a0c..6e6e31a5698 100644
--- a/tests/ui/span/suggestion-non-ascii.stderr
+++ b/tests/ui/span/suggestion-non-ascii.stderr
@@ -4,6 +4,6 @@ error[E0608]: cannot index into a value of type `({integer},)`
 LL |     println!("☃{}", tup[0]);
    |                        ^^^ help: to access tuple elements, use: `.0`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0608`.
diff --git a/tests/ui/span/transitive-dep-span.stderr b/tests/ui/span/transitive-dep-span.stderr
index 4dc3e572116..c0f3f3a65c7 100644
--- a/tests/ui/span/transitive-dep-span.stderr
+++ b/tests/ui/span/transitive-dep-span.stderr
@@ -14,5 +14,5 @@ LL | transitive_dep_two::parse_error!();
    | in this macro invocation
    | in this macro invocation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/span/type-annotations-needed-expr.stderr b/tests/ui/span/type-annotations-needed-expr.stderr
index 65a90318a3c..a548df052b8 100644
--- a/tests/ui/span/type-annotations-needed-expr.stderr
+++ b/tests/ui/span/type-annotations-needed-expr.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     let _ = (vec![1,2,3]).into_iter().sum::<S>() as f64;
    |                                          +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/span/type-binding.stderr b/tests/ui/span/type-binding.stderr
index cb0aefe0609..5df74fa2fa2 100644
--- a/tests/ui/span/type-binding.stderr
+++ b/tests/ui/span/type-binding.stderr
@@ -4,6 +4,6 @@ error[E0220]: associated type `Trget` not found for `Deref`
 LL | fn homura<T: Deref<Trget = i32>>(_: T) {}
    |                    ^^^^^ help: there is an associated type with a similar name: `Target`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/ui/span/wf-method-late-bound-regions.stderr b/tests/ui/span/wf-method-late-bound-regions.stderr
index 64c2d0f1606..09d6714e777 100644
--- a/tests/ui/span/wf-method-late-bound-regions.stderr
+++ b/tests/ui/span/wf-method-late-bound-regions.stderr
@@ -10,6 +10,6 @@ LL |         f2.xmute(&pointer)
 LL |     };
    |     - `pointer` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/specialization/default-associated-type-bound-1.stderr b/tests/ui/specialization/default-associated-type-bound-1.stderr
index e498187c0a1..516df555a0d 100644
--- a/tests/ui/specialization/default-associated-type-bound-1.stderr
+++ b/tests/ui/specialization/default-associated-type-bound-1.stderr
@@ -21,6 +21,6 @@ note: required by a bound in `X::U`
 LL |     type U: Clone;
    |             ^^^^^ required by this bound in `X::U`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/default-associated-type-bound-2.stderr b/tests/ui/specialization/default-associated-type-bound-2.stderr
index 4dbe251ed5e..e02a945d9a9 100644
--- a/tests/ui/specialization/default-associated-type-bound-2.stderr
+++ b/tests/ui/specialization/default-associated-type-bound-2.stderr
@@ -25,6 +25,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | impl<B: 'static, T> X<B> for T where &'static B: PartialEq<B> {
    |                                ++++++++++++++++++++++++++++++
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/default-generic-associated-type-bound.stderr b/tests/ui/specialization/default-generic-associated-type-bound.stderr
index c597eed3790..afdbe2eb226 100644
--- a/tests/ui/specialization/default-generic-associated-type-bound.stderr
+++ b/tests/ui/specialization/default-generic-associated-type-bound.stderr
@@ -25,6 +25,6 @@ help: consider further restricting this bound
 LL | impl<T: 'static + std::cmp::PartialEq> X for T {
    |                 +++++++++++++++++++++
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr b/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr
index 64e14f5800f..18edcad0a47 100644
--- a/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr
@@ -9,6 +9,6 @@ LL | | }
    = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
    = help: add `#![feature(specialization)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr
index f19975060a4..d3441b0e8b9 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-item-not-implemented.stderr
@@ -17,6 +17,6 @@ LL |     fn foo_two(&self) -> &'static str;
 LL | impl Foo for MyStruct {}
    | ^^^^^^^^^^^^^^^^^^^^^ missing `foo_two` in implementation
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr b/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr
index 37788612f43..75c91e4806f 100644
--- a/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-trait-not-implemented.stderr
@@ -39,6 +39,6 @@ note: `Foo` defines an item `foo_one`, perhaps you need to implement it
 LL | trait Foo {
    | ^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
index e7801603493..01188e293bd 100644
--- a/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
+++ b/tests/ui/specialization/defaultimpl/specialization-wfcheck.stderr
@@ -24,6 +24,6 @@ help: consider restricting type parameter `U`
 LL | default impl<U: std::cmp::Eq> Foo<'static, U> for () {}
    |               ++++++++++++++
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/issue-111232.stderr b/tests/ui/specialization/issue-111232.stderr
index 27ee42fc00c..ed392e4f915 100644
--- a/tests/ui/specialization/issue-111232.stderr
+++ b/tests/ui/specialization/issue-111232.stderr
@@ -6,6 +6,6 @@ LL |     fn from(s: S) -> S {
    |
    = note: parent implementation is in crate `core`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/specialization/issue-33017.stderr b/tests/ui/specialization/issue-33017.stderr
index 78e94cec2c0..2c20077078f 100644
--- a/tests/ui/specialization/issue-33017.stderr
+++ b/tests/ui/specialization/issue-33017.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::marker::Copy> UncheckedCopy for T {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/issue-38091-2.stderr b/tests/ui/specialization/issue-38091-2.stderr
index 5a05f9c270a..828a8e93399 100644
--- a/tests/ui/specialization/issue-38091-2.stderr
+++ b/tests/ui/specialization/issue-38091-2.stderr
@@ -19,6 +19,6 @@ LL | where
 LL |     T: Check,
    |        ----- unsatisfied trait bound introduced here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/specialization/issue-38091.stderr b/tests/ui/specialization/issue-38091.stderr
index 4d840482b46..eb64383e18b 100644
--- a/tests/ui/specialization/issue-38091.stderr
+++ b/tests/ui/specialization/issue-38091.stderr
@@ -25,6 +25,6 @@ note: required by a bound in `Iterate::Ty`
 LL |     type Ty: Valid;
    |              ^^^^^ required by this bound in `Iterate::Ty`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/issue-39448.stderr b/tests/ui/specialization/issue-39448.stderr
index 9ce51d1136d..dc5db4f4285 100644
--- a/tests/ui/specialization/issue-39448.stderr
+++ b/tests/ui/specialization/issue-39448.stderr
@@ -30,6 +30,6 @@ LL | where
 LL |     U: FromA<T>,
    |        -------- unsatisfied trait bound introduced here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/specialization/issue-43037.current.stderr b/tests/ui/specialization/issue-43037.current.stderr
index 26db9d7c997..27113509257 100644
--- a/tests/ui/specialization/issue-43037.current.stderr
+++ b/tests/ui/specialization/issue-43037.current.stderr
@@ -7,6 +7,6 @@ LL | impl<T> From<<A<T> as Z>::Assoc> for T {}
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/specialization/issue-43037.negative.stderr b/tests/ui/specialization/issue-43037.negative.stderr
index 26db9d7c997..27113509257 100644
--- a/tests/ui/specialization/issue-43037.negative.stderr
+++ b/tests/ui/specialization/issue-43037.negative.stderr
@@ -7,6 +7,6 @@ LL | impl<T> From<<A<T> as Z>::Assoc> for T {}
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/specialization/issue-44861.stderr b/tests/ui/specialization/issue-44861.stderr
index 1941d40fee8..d184c4468b6 100644
--- a/tests/ui/specialization/issue-44861.stderr
+++ b/tests/ui/specialization/issue-44861.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Smartass::Data2`
 LL |     type Data2: CoerceUnsized<*const [u8]>;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Smartass::Data2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/issue-45814.current.stderr b/tests/ui/specialization/issue-45814.current.stderr
index 5013559b80e..da0dff78e26 100644
--- a/tests/ui/specialization/issue-45814.current.stderr
+++ b/tests/ui/specialization/issue-45814.current.stderr
@@ -9,6 +9,6 @@ LL | default impl<T, U> Trait<T> for U {}
    = note: 128 redundant requirements hidden
    = note: required for `T` to implement `Trait<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/specialization/issue-45814.negative.stderr b/tests/ui/specialization/issue-45814.negative.stderr
index 5013559b80e..da0dff78e26 100644
--- a/tests/ui/specialization/issue-45814.negative.stderr
+++ b/tests/ui/specialization/issue-45814.negative.stderr
@@ -9,6 +9,6 @@ LL | default impl<T, U> Trait<T> for U {}
    = note: 128 redundant requirements hidden
    = note: required for `T` to implement `Trait<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/specialization/issue-50452-fail.stderr b/tests/ui/specialization/issue-50452-fail.stderr
index 3fc29fff230..7ac4b39993c 100644
--- a/tests/ui/specialization/issue-50452-fail.stderr
+++ b/tests/ui/specialization/issue-50452-fail.stderr
@@ -19,6 +19,6 @@ LL | impl<T> Foo for T {
    |
    = note: to specialize, `foo` in the parent `impl` must be marked `default`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0520`.
diff --git a/tests/ui/specialization/issue-51892.stderr b/tests/ui/specialization/issue-51892.stderr
index cb46db83606..9553a04c8f6 100644
--- a/tests/ui/specialization/issue-51892.stderr
+++ b/tests/ui/specialization/issue-51892.stderr
@@ -6,5 +6,5 @@ LL |     type Type = [u8; std::mem::size_of::<<T as Trait>::Type>()];
    |
    = help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<<T as Trait>::Type>()]:`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/issue-52050.stderr b/tests/ui/specialization/issue-52050.stderr
index 85aac16f6d0..3b0cac51464 100644
--- a/tests/ui/specialization/issue-52050.stderr
+++ b/tests/ui/specialization/issue-52050.stderr
@@ -21,6 +21,6 @@ LL |   impl IntoPyDictPointer for ()
    |
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `()` in future versions
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/issue-59435.stderr b/tests/ui/specialization/issue-59435.stderr
index e8a12e4d928..60522e0f587 100644
--- a/tests/ui/specialization/issue-59435.stderr
+++ b/tests/ui/specialization/issue-59435.stderr
@@ -15,6 +15,6 @@ LL + #[derive(Default)]
 LL | struct MyStruct {}
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/specialization/issue-68830-spurious-diagnostics.stderr b/tests/ui/specialization/issue-68830-spurious-diagnostics.stderr
index 833f61dca8c..0ecec03a023 100644
--- a/tests/ui/specialization/issue-68830-spurious-diagnostics.stderr
+++ b/tests/ui/specialization/issue-68830-spurious-diagnostics.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `MissingType` in this scope
 LL |     err: MissingType
    |          ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
index 83f311efd39..def4a413af1 100644
--- a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
+++ b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
@@ -10,5 +10,5 @@ note: required by a bound in `S`
 LL | struct S<const L: usize>;
    |          ^^^^^^^^^^^^^^ required by this bound in `S`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/impl-on-nonexisting.stderr b/tests/ui/specialization/min_specialization/impl-on-nonexisting.stderr
index b032ccbe53f..85b492c0503 100644
--- a/tests/ui/specialization/min_specialization/impl-on-nonexisting.stderr
+++ b/tests/ui/specialization/min_specialization/impl-on-nonexisting.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `NonExistent` in this scope
 LL | impl Trait for NonExistent {}
    |                ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/specialization/min_specialization/impl_specialization_trait.stderr b/tests/ui/specialization/min_specialization/impl_specialization_trait.stderr
index 934103d49dc..553bee2d2dd 100644
--- a/tests/ui/specialization/min_specialization/impl_specialization_trait.stderr
+++ b/tests/ui/specialization/min_specialization/impl_specialization_trait.stderr
@@ -6,5 +6,5 @@ LL | impl specialization_trait::SpecTrait for A {
    |
    = help: add `#![feature(min_specialization)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/repeated_projection_type.stderr b/tests/ui/specialization/min_specialization/repeated_projection_type.stderr
index a751ba79347..01fd04dd3d0 100644
--- a/tests/ui/specialization/min_specialization/repeated_projection_type.stderr
+++ b/tests/ui/specialization/min_specialization/repeated_projection_type.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on associated type `<V as Id>::This == (I,)`
 LL | impl<I, V: Id<This = (I,)>> X for V {
    |               ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/repeating_lifetimes.stderr b/tests/ui/specialization/min_specialization/repeating_lifetimes.stderr
index 16dccb10b45..d80ee7b579d 100644
--- a/tests/ui/specialization/min_specialization/repeating_lifetimes.stderr
+++ b/tests/ui/specialization/min_specialization/repeating_lifetimes.stderr
@@ -4,5 +4,5 @@ error: specializing impl repeats parameter `'a`
 LL | impl<'a> X for (&'a u8, &'a u8) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/repeating_param.stderr b/tests/ui/specialization/min_specialization/repeating_param.stderr
index 5e6adf723b5..90ec4b945e0 100644
--- a/tests/ui/specialization/min_specialization/repeating_param.stderr
+++ b/tests/ui/specialization/min_specialization/repeating_param.stderr
@@ -4,5 +4,5 @@ error: specializing impl repeats parameter `T`
 LL | impl<T> X for (T, T) {
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/spec-marker-supertraits.stderr b/tests/ui/specialization/min_specialization/spec-marker-supertraits.stderr
index ba9d6bbe300..42c0de85e52 100644
--- a/tests/ui/specialization/min_specialization/spec-marker-supertraits.stderr
+++ b/tests/ui/specialization/min_specialization/spec-marker-supertraits.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on trait `HasMethod`
 LL | impl<T: Marker> Spec for T {
    |         ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/specialization_super_trait.stderr b/tests/ui/specialization/min_specialization/specialization_super_trait.stderr
index e935786624b..1fc064a0a3d 100644
--- a/tests/ui/specialization/min_specialization/specialization_super_trait.stderr
+++ b/tests/ui/specialization/min_specialization/specialization_super_trait.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on trait `Default`
 LL | impl<T: Default> SpecMarker for T {
    |         ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/specialize_nothing.stderr b/tests/ui/specialization/min_specialization/specialize_nothing.stderr
index 65f73781cae..8e7dc9c5ef3 100644
--- a/tests/ui/specialization/min_specialization/specialize_nothing.stderr
+++ b/tests/ui/specialization/min_specialization/specialize_nothing.stderr
@@ -10,5 +10,5 @@ note: impl is a specialization of this impl
 LL | impl<T> Special for T {
    | ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/specialize_on_static.stderr b/tests/ui/specialization/min_specialization/specialize_on_static.stderr
index 9a16798f15c..8c2bf6c2da0 100644
--- a/tests/ui/specialization/min_specialization/specialize_on_static.stderr
+++ b/tests/ui/specialization/min_specialization/specialize_on_static.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on `'static` lifetime
 LL | impl X for &'static u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/specialize_on_trait.stderr b/tests/ui/specialization/min_specialization/specialize_on_trait.stderr
index 7b79c7eb4ad..c86b4ac3915 100644
--- a/tests/ui/specialization/min_specialization/specialize_on_trait.stderr
+++ b/tests/ui/specialization/min_specialization/specialize_on_trait.stderr
@@ -4,5 +4,5 @@ error: cannot specialize on trait `SpecMarker`
 LL | impl<T: SpecMarker> X for T {
    |         ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/min_specialization/specialize_on_type_error.stderr b/tests/ui/specialization/min_specialization/specialize_on_type_error.stderr
index cc12302bd8c..1686f6f0cd6 100644
--- a/tests/ui/specialization/min_specialization/specialize_on_type_error.stderr
+++ b/tests/ui/specialization/min_specialization/specialize_on_type_error.stderr
@@ -7,6 +7,6 @@ LL |     type Assoc: Y;
 LL | impl<T: X> Z for A<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^ missing `Assoc` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/specialization/specialization-default-items-drop-coherence.coherence.stderr b/tests/ui/specialization/specialization-default-items-drop-coherence.coherence.stderr
index 578db0cc65e..e9498a00317 100644
--- a/tests/ui/specialization/specialization-default-items-drop-coherence.coherence.stderr
+++ b/tests/ui/specialization/specialization-default-items-drop-coherence.coherence.stderr
@@ -7,6 +7,6 @@ LL | impl Overlap for u32 {
 LL | impl Overlap for <u32 as Default>::Id {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/specialization-default-items-drop-coherence.next.stderr b/tests/ui/specialization/specialization-default-items-drop-coherence.next.stderr
index 578db0cc65e..e9498a00317 100644
--- a/tests/ui/specialization/specialization-default-items-drop-coherence.next.stderr
+++ b/tests/ui/specialization/specialization-default-items-drop-coherence.next.stderr
@@ -7,6 +7,6 @@ LL | impl Overlap for u32 {
 LL | impl Overlap for <u32 as Default>::Id {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/specialization-feature-gate-default.stderr b/tests/ui/specialization/specialization-feature-gate-default.stderr
index 42dbb200c24..35e5e3bc512 100644
--- a/tests/ui/specialization/specialization-feature-gate-default.stderr
+++ b/tests/ui/specialization/specialization-feature-gate-default.stderr
@@ -7,6 +7,6 @@ LL |     default fn foo(&self) {}
    = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
    = help: add `#![feature(specialization)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/specialization/specialization-feature-gate-overlap.stderr b/tests/ui/specialization/specialization-feature-gate-overlap.stderr
index 9157ad0d46a..f42289fb962 100644
--- a/tests/ui/specialization/specialization-feature-gate-overlap.stderr
+++ b/tests/ui/specialization/specialization-feature-gate-overlap.stderr
@@ -7,6 +7,6 @@ LL | impl<T> Foo for T {
 LL | impl Foo for u8 {
    | ^^^^^^^^^^^^^^^ conflicting implementation for `u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/specialization/specialization-overlap-hygiene.stderr b/tests/ui/specialization/specialization-overlap-hygiene.stderr
index 81efd46cc7f..b143f888f23 100644
--- a/tests/ui/specialization/specialization-overlap-hygiene.stderr
+++ b/tests/ui/specialization/specialization-overlap-hygiene.stderr
@@ -7,6 +7,6 @@ LL |     fn f() {}
 LL |    fn f() {}
    |    ^^^^^^ duplicate definitions for `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/specialization/specialization-overlap-negative.stderr b/tests/ui/specialization/specialization-overlap-negative.stderr
index 1fe4869ff54..a8e99953e2b 100644
--- a/tests/ui/specialization/specialization-overlap-negative.stderr
+++ b/tests/ui/specialization/specialization-overlap-negative.stderr
@@ -16,6 +16,6 @@ LL | unsafe impl<T: Clone> Send for TestType<T> {}
 LL | impl<T: MyTrait> !Send for TestType<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ negative implementation here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/stability-attribute/accidental-stable-in-unstable.stderr b/tests/ui/stability-attribute/accidental-stable-in-unstable.stderr
index ff733822cab..f85b3c6eb66 100644
--- a/tests/ui/stability-attribute/accidental-stable-in-unstable.stderr
+++ b/tests/ui/stability-attribute/accidental-stable-in-unstable.stderr
@@ -6,6 +6,6 @@ LL | use core::unicode::UNICODE_VERSION;
    |
    = help: add `#![feature(unicode_internals)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/stability-attribute/allowed-through-unstable.stderr b/tests/ui/stability-attribute/allowed-through-unstable.stderr
index 132c00b89b2..f09289bfb89 100644
--- a/tests/ui/stability-attribute/allowed-through-unstable.stderr
+++ b/tests/ui/stability-attribute/allowed-through-unstable.stderr
@@ -7,6 +7,6 @@ LL | use allowed_through_unstable_core::unstable_module::NewStableTraitNotAllowe
    = note: see issue #1 <https://github.com/rust-lang/rust/issues/1> for more information
    = help: add `#![feature(unstable_test_feature)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/stability-attribute/const-stability-attribute-implies-missing.stderr b/tests/ui/stability-attribute/const-stability-attribute-implies-missing.stderr
index 6d8b01a5495..232de41c769 100644
--- a/tests/ui/stability-attribute/const-stability-attribute-implies-missing.stderr
+++ b/tests/ui/stability-attribute/const-stability-attribute-implies-missing.stderr
@@ -4,5 +4,5 @@ error: feature `const_bar` implying `const_foobar` does not exist
 LL | #[rustc_const_unstable(feature = "const_foobar", issue = "1", implied_by = "const_bar")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/const-stability-attribute-implies-no-feature.stderr b/tests/ui/stability-attribute/const-stability-attribute-implies-no-feature.stderr
index 8ef5a364ecc..0a5f58288fa 100644
--- a/tests/ui/stability-attribute/const-stability-attribute-implies-no-feature.stderr
+++ b/tests/ui/stability-attribute/const-stability-attribute-implies-no-feature.stderr
@@ -6,5 +6,5 @@ LL |     foobar();
    |
    = help: add `#![feature(const_foobar)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/const-stability-attribute-implies-using-stable.stderr b/tests/ui/stability-attribute/const-stability-attribute-implies-using-stable.stderr
index f6a099cd25e..050834ab676 100644
--- a/tests/ui/stability-attribute/const-stability-attribute-implies-using-stable.stderr
+++ b/tests/ui/stability-attribute/const-stability-attribute-implies-using-stable.stderr
@@ -18,5 +18,5 @@ help: if you are using features which are now stable, remove this line
 LL - #![feature(const_foo)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/const-stability-attribute-implies-using-unstable.stderr b/tests/ui/stability-attribute/const-stability-attribute-implies-using-unstable.stderr
index 06385667658..50cc14c3b4f 100644
--- a/tests/ui/stability-attribute/const-stability-attribute-implies-using-unstable.stderr
+++ b/tests/ui/stability-attribute/const-stability-attribute-implies-using-unstable.stderr
@@ -18,5 +18,5 @@ help: if you are using features which are now stable, remove this line
 LL - #![feature(const_foo)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/generics-default-stability-where.stderr b/tests/ui/stability-attribute/generics-default-stability-where.stderr
index 61253adc892..ce34f96771c 100644
--- a/tests/ui/stability-attribute/generics-default-stability-where.stderr
+++ b/tests/ui/stability-attribute/generics-default-stability-where.stderr
@@ -6,6 +6,6 @@ LL | impl<T> Trait3<usize> for T where T: Trait2<usize> {
    |
    = help: add `#![feature(unstable_default)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/stability-attribute/issue-28075.stderr b/tests/ui/stability-attribute/issue-28075.stderr
index 7e53bb54457..e16eae88b01 100644
--- a/tests/ui/stability-attribute/issue-28075.stderr
+++ b/tests/ui/stability-attribute/issue-28075.stderr
@@ -6,6 +6,6 @@ LL | use lint_stability::{unstable, deprecated};
    |
    = help: add `#![feature(unstable_test_feature)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/stability-attribute/issue-28388-3.stderr b/tests/ui/stability-attribute/issue-28388-3.stderr
index d2e46683b90..0fb62ece313 100644
--- a/tests/ui/stability-attribute/issue-28388-3.stderr
+++ b/tests/ui/stability-attribute/issue-28388-3.stderr
@@ -6,6 +6,6 @@ LL | use lint_stability::UnstableEnum::{};
    |
    = help: add `#![feature(unstable_test_feature)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/stability-attribute/missing-stability-attr-at-top-level.stderr b/tests/ui/stability-attribute/missing-stability-attr-at-top-level.stderr
index c7ade234d3d..3af1e82d207 100644
--- a/tests/ui/stability-attribute/missing-stability-attr-at-top-level.stderr
+++ b/tests/ui/stability-attribute/missing-stability-attr-at-top-level.stderr
@@ -7,5 +7,5 @@ LL | |
 LL | | fn main() {}
    | |____________^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/stability-attribute-implies-missing.stderr b/tests/ui/stability-attribute/stability-attribute-implies-missing.stderr
index ff1856f1763..63890092ebc 100644
--- a/tests/ui/stability-attribute/stability-attribute-implies-missing.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-implies-missing.stderr
@@ -4,5 +4,5 @@ error: feature `bar` implying `foobar` does not exist
 LL | #[unstable(feature = "foobar", issue = "1", implied_by = "bar")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/stability-attribute-implies-using-stable.stderr b/tests/ui/stability-attribute/stability-attribute-implies-using-stable.stderr
index c9b3f07cc70..d783f1e8e40 100644
--- a/tests/ui/stability-attribute/stability-attribute-implies-using-stable.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-implies-using-stable.stderr
@@ -18,5 +18,5 @@ help: if you are using features which are now stable, remove this line
 LL - #![feature(foo)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/stability-attribute-implies-using-unstable.stderr b/tests/ui/stability-attribute/stability-attribute-implies-using-unstable.stderr
index 9a5c7ef5a47..4940650fd42 100644
--- a/tests/ui/stability-attribute/stability-attribute-implies-using-unstable.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-implies-using-unstable.stderr
@@ -18,5 +18,5 @@ help: if you are using features which are now stable, remove this line
 LL - #![feature(foo)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr b/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr
index b1c56ef224a..a6d1ebf2945 100644
--- a/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr
@@ -6,5 +6,5 @@ LL | |     () => ()
 LL | | }
    | |_^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/stability-attribute/stability-in-private-module.stderr b/tests/ui/stability-attribute/stability-in-private-module.stderr
index cc8758714fc..9eb4d3efc8b 100644
--- a/tests/ui/stability-attribute/stability-in-private-module.stderr
+++ b/tests/ui/stability-attribute/stability-in-private-module.stderr
@@ -9,6 +9,6 @@ LL |     let _ = std::thread::thread_info::current_thread();
 note: the module `thread_info` is defined here
   --> $SRC_DIR/std/src/thread/mod.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/stability-attribute/unresolved_stability_lint.stderr b/tests/ui/stability-attribute/unresolved_stability_lint.stderr
index 11d6abcaf36..51780d20880 100644
--- a/tests/ui/stability-attribute/unresolved_stability_lint.stderr
+++ b/tests/ui/stability-attribute/unresolved_stability_lint.stderr
@@ -4,6 +4,6 @@ error[E0405]: cannot find trait `Foo` in this scope
 LL | impl Foo for () {}
    |      ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/static/bad-const-type.stderr b/tests/ui/static/bad-const-type.stderr
index 2e930f4596e..807cd2f7a25 100644
--- a/tests/ui/static/bad-const-type.stderr
+++ b/tests/ui/static/bad-const-type.stderr
@@ -6,6 +6,6 @@ LL | static i: String = 10;
    |                    |
    |                    expected `String`, found integer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/static/issue-18118-2.stderr b/tests/ui/static/issue-18118-2.stderr
index 4fc3ca78f96..6231a276f99 100644
--- a/tests/ui/static/issue-18118-2.stderr
+++ b/tests/ui/static/issue-18118-2.stderr
@@ -6,6 +6,6 @@ LL |         &p
    |
    = help: consider extracting the value of the `static` to a `const`, and referring to that
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0013`.
diff --git a/tests/ui/static/issue-18118.stderr b/tests/ui/static/issue-18118.stderr
index 035be2b1202..1c53abaa295 100644
--- a/tests/ui/static/issue-18118.stderr
+++ b/tests/ui/static/issue-18118.stderr
@@ -11,6 +11,6 @@ LL |         &p
 LL |     };
    |     - `p` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/static/static-closures.stderr b/tests/ui/static/static-closures.stderr
index 99235e26e15..b11c0b5a530 100644
--- a/tests/ui/static/static-closures.stderr
+++ b/tests/ui/static/static-closures.stderr
@@ -4,6 +4,6 @@ error[E0697]: closures cannot be static
 LL |     static || {};
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0697`.
diff --git a/tests/ui/static/static-items-cant-move.stderr b/tests/ui/static/static-items-cant-move.stderr
index 235e9ee9b91..1361e7089e8 100644
--- a/tests/ui/static/static-items-cant-move.stderr
+++ b/tests/ui/static/static-items-cant-move.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of static item `BAR`
 LL |     test(BAR);
    |          ^^^ move occurs because `BAR` has type `Foo`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/static/static-lifetime-bound.stderr b/tests/ui/static/static-lifetime-bound.stderr
index 19e55a6582e..8b0d3a0bf4c 100644
--- a/tests/ui/static/static-lifetime-bound.stderr
+++ b/tests/ui/static/static-lifetime-bound.stderr
@@ -11,6 +11,6 @@ LL |     f(&x);
 LL | }
    | - `x` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/static/static-lifetime.stderr b/tests/ui/static/static-lifetime.stderr
index 4af3370c799..8c9434ce3cb 100644
--- a/tests/ui/static/static-lifetime.stderr
+++ b/tests/ui/static/static-lifetime.stderr
@@ -11,6 +11,6 @@ LL | impl<'a, A: Clone> Arbitrary for ::std::borrow::Cow<'a, A> {}
    |      ^^
    = note: but lifetime parameter must outlive the static lifetime
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0478`.
diff --git a/tests/ui/static/static-method-privacy.stderr b/tests/ui/static/static-method-privacy.stderr
index 4be1b22fc6b..3c77b9000fd 100644
--- a/tests/ui/static/static-method-privacy.stderr
+++ b/tests/ui/static/static-method-privacy.stderr
@@ -7,6 +7,6 @@ LL |         fn new() -> S { S }
 LL |     let _ = a::S::new();
    |                   ^^^ private associated function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/static/static-mut-bad-types.stderr b/tests/ui/static/static-mut-bad-types.stderr
index 983e1026f91..f71701ca7a4 100644
--- a/tests/ui/static/static-mut-bad-types.stderr
+++ b/tests/ui/static/static-mut-bad-types.stderr
@@ -7,6 +7,6 @@ LL | static mut a: isize = 3;
 LL |         a = true;
    |             ^^^^ expected `isize`, found `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/static/static-mut-not-constant.stderr b/tests/ui/static/static-mut-not-constant.stderr
index 8411a1557b4..d125bec5943 100644
--- a/tests/ui/static/static-mut-not-constant.stderr
+++ b/tests/ui/static/static-mut-not-constant.stderr
@@ -7,6 +7,6 @@ LL | static mut a: Box<isize> = Box::new(3);
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/static/static-reference-to-fn-1.stderr b/tests/ui/static/static-reference-to-fn-1.stderr
index 86c4eaa7eb4..ce9b6a739cf 100644
--- a/tests/ui/static/static-reference-to-fn-1.stderr
+++ b/tests/ui/static/static-reference-to-fn-1.stderr
@@ -12,6 +12,6 @@ help: consider casting to a fn pointer
 LL |         func: &(foo as fn() -> Option<isize>),
    |               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/static/static-region-bound.stderr b/tests/ui/static/static-region-bound.stderr
index 1a607e3c014..a47c9457102 100644
--- a/tests/ui/static/static-region-bound.stderr
+++ b/tests/ui/static/static-region-bound.stderr
@@ -8,6 +8,6 @@ LL |     f(x);
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/static/static-vec-repeat-not-constant.stderr b/tests/ui/static/static-vec-repeat-not-constant.stderr
index dec0123184d..db0c7eb8d35 100644
--- a/tests/ui/static/static-vec-repeat-not-constant.stderr
+++ b/tests/ui/static/static-vec-repeat-not-constant.stderr
@@ -7,6 +7,6 @@ LL | static a: [isize; 2] = [foo(); 2];
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/statics/issue-14227.mir.stderr b/tests/ui/statics/issue-14227.mir.stderr
index 8e7a2514dd6..ab50b97d63f 100644
--- a/tests/ui/statics/issue-14227.mir.stderr
+++ b/tests/ui/statics/issue-14227.mir.stderr
@@ -6,6 +6,6 @@ LL | static CRASH: u32 = symbol;
    |
    = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/statics/issue-14227.thir.stderr b/tests/ui/statics/issue-14227.thir.stderr
index 8e7a2514dd6..ab50b97d63f 100644
--- a/tests/ui/statics/issue-14227.thir.stderr
+++ b/tests/ui/statics/issue-14227.thir.stderr
@@ -6,6 +6,6 @@ LL | static CRASH: u32 = symbol;
    |
    = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/statics/issue-17718-static-sync.stderr b/tests/ui/statics/issue-17718-static-sync.stderr
index bc6e45e5925..96f894146c5 100644
--- a/tests/ui/statics/issue-17718-static-sync.stderr
+++ b/tests/ui/statics/issue-17718-static-sync.stderr
@@ -7,6 +7,6 @@ LL | static BAR: Foo = Foo;
    = help: the trait `Sync` is not implemented for `Foo`
    = note: shared static variables must have a type that implements `Sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/statics/issue-44373.stderr b/tests/ui/statics/issue-44373.stderr
index 2d29dec888e..3bbcfdd8534 100644
--- a/tests/ui/statics/issue-44373.stderr
+++ b/tests/ui/statics/issue-44373.stderr
@@ -8,6 +8,6 @@ LL |     let _val: &'static [&'static u32] = &[&FOO];
 LL | }
    | - temporary value is freed at the end of this statement
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/str/str-as-char.stderr b/tests/ui/str/str-as-char.stderr
index c3cb488e3d1..44ec079e929 100644
--- a/tests/ui/str/str-as-char.stderr
+++ b/tests/ui/str/str-as-char.stderr
@@ -9,5 +9,5 @@ help: if you meant to write a `str` literal, use double quotes
 LL |     println!("●●");
    |              ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/str/str-concat-on-double-ref.stderr b/tests/ui/str/str-concat-on-double-ref.stderr
index bd354679f78..85a1db8adcc 100644
--- a/tests/ui/str/str-concat-on-double-ref.stderr
+++ b/tests/ui/str/str-concat-on-double-ref.stderr
@@ -13,6 +13,6 @@ help: create an owned `String` from a string reference
 LL |     let c = a.to_owned() + b;
    |              +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/structs-enums/enum-rec/issue-17431-6.stderr b/tests/ui/structs-enums/enum-rec/issue-17431-6.stderr
index e0a8225507e..e34eb04bc04 100644
--- a/tests/ui/structs-enums/enum-rec/issue-17431-6.stderr
+++ b/tests/ui/structs-enums/enum-rec/issue-17431-6.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | enum Foo { X(Mutex<Option<Box<Foo>>>) }
    |                           ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/enum-rec/issue-17431-7.stderr b/tests/ui/structs-enums/enum-rec/issue-17431-7.stderr
index ecf072b8e8a..792ef4428e3 100644
--- a/tests/ui/structs-enums/enum-rec/issue-17431-7.stderr
+++ b/tests/ui/structs-enums/enum-rec/issue-17431-7.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | enum Foo { Voo(Option<Option<Box<Foo>>>) }
    |                              ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/issue-103869.stderr b/tests/ui/structs-enums/issue-103869.stderr
index 4665ebf89a3..2334e5e9712 100644
--- a/tests/ui/structs-enums/issue-103869.stderr
+++ b/tests/ui/structs-enums/issue-103869.stderr
@@ -13,5 +13,5 @@ help: perhaps you meant to use `struct` here
 LL | struct VecOrMap {
    | ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/structs-enums/issue-2718-a.stderr b/tests/ui/structs-enums/issue-2718-a.stderr
index 7ea620f386a..4253fae03c0 100644
--- a/tests/ui/structs-enums/issue-2718-a.stderr
+++ b/tests/ui/structs-enums/issue-2718-a.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     pub struct Pong(Box<SendPacket<Ping>>);
    |                     ++++                +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/issue-3008-1.stderr b/tests/ui/structs-enums/issue-3008-1.stderr
index be25b9091d5..d7464dc56a7 100644
--- a/tests/ui/structs-enums/issue-3008-1.stderr
+++ b/tests/ui/structs-enums/issue-3008-1.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     BarSome(Box<Bar>)
    |             ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/issue-3008-2.stderr b/tests/ui/structs-enums/issue-3008-2.stderr
index 858a8fd6af8..4ed1c1816ea 100644
--- a/tests/ui/structs-enums/issue-3008-2.stderr
+++ b/tests/ui/structs-enums/issue-3008-2.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | struct Bar { x: Box<Bar> }
    |                 ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/issue-3008-3.stderr b/tests/ui/structs-enums/issue-3008-3.stderr
index a1a81e29367..9358060a87b 100644
--- a/tests/ui/structs-enums/issue-3008-3.stderr
+++ b/tests/ui/structs-enums/issue-3008-3.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | enum E2<T> { V2(Box<E2<E1>>, marker::PhantomData<T>), }
    |                 ++++      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-enum-ignoring-field-with-underscore.stderr b/tests/ui/structs-enums/struct-enum-ignoring-field-with-underscore.stderr
index 2f3a150e5cb..664a00e3303 100644
--- a/tests/ui/structs-enums/struct-enum-ignoring-field-with-underscore.stderr
+++ b/tests/ui/structs-enums/struct-enum-ignoring-field-with-underscore.stderr
@@ -9,5 +9,5 @@ help: to omit remaining fields, use `..`
 LL |     if let Some(Foo::Bar {..}) = foo {}
    |                           ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/structs-enums/struct-rec/issue-17431-1.stderr b/tests/ui/structs-enums/struct-rec/issue-17431-1.stderr
index e3af8976cee..b28c3de2417 100644
--- a/tests/ui/structs-enums/struct-rec/issue-17431-1.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-17431-1.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | struct Foo { foo: Option<Option<Box<Foo>>> }
    |                                 ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-rec/issue-17431-2.stderr b/tests/ui/structs-enums/struct-rec/issue-17431-2.stderr
index 39a99ec1ef7..cdf51632acd 100644
--- a/tests/ui/structs-enums/struct-rec/issue-17431-2.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-17431-2.stderr
@@ -15,6 +15,6 @@ LL |
 LL ~ struct Foo { q: Option<Box<Baz>> }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-rec/issue-17431-3.stderr b/tests/ui/structs-enums/struct-rec/issue-17431-3.stderr
index 394134c7855..e788b2ed0f8 100644
--- a/tests/ui/structs-enums/struct-rec/issue-17431-3.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-17431-3.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | struct Foo { foo: Mutex<Option<Box<Foo>>> }
    |                                ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-rec/issue-17431-4.stderr b/tests/ui/structs-enums/struct-rec/issue-17431-4.stderr
index 3d141e44bab..3208effc000 100644
--- a/tests/ui/structs-enums/struct-rec/issue-17431-4.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-17431-4.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | struct Foo<T> { foo: Option<Option<Box<Foo<T>>>>, marker: marker::PhantomData<T> }
    |                                    ++++      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-rec/issue-17431-5.stderr b/tests/ui/structs-enums/struct-rec/issue-17431-5.stderr
index 44a90a6fe38..1b943bf8956 100644
--- a/tests/ui/structs-enums/struct-rec/issue-17431-5.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-17431-5.stderr
@@ -9,6 +9,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL | struct Bar<T> { x: Box<Bar<Foo>> , marker: marker::PhantomData<T> }
    |                    ++++        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-rec/issue-74224.stderr b/tests/ui/structs-enums/struct-rec/issue-74224.stderr
index f1d50bc8af5..550b078a6a2 100644
--- a/tests/ui/structs-enums/struct-rec/issue-74224.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-74224.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     y: Box<A<A<T>>>,
    |        ++++       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs-enums/struct-rec/issue-84611.stderr b/tests/ui/structs-enums/struct-rec/issue-84611.stderr
index 536f54e3e96..2d971cfc8b6 100644
--- a/tests/ui/structs-enums/struct-rec/issue-84611.stderr
+++ b/tests/ui/structs-enums/struct-rec/issue-84611.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     x: Box<Foo<[T; 1]>>,
    |        ++++           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/structs/incomplete-fn-in-struct-definition.stderr b/tests/ui/structs/incomplete-fn-in-struct-definition.stderr
index 0d12ba9c916..15850962bbc 100644
--- a/tests/ui/structs/incomplete-fn-in-struct-definition.stderr
+++ b/tests/ui/structs/incomplete-fn-in-struct-definition.stderr
@@ -11,5 +11,5 @@ help: escape `fn` to use it as an identifier
 LL |     r#fn: u8
    |     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/structs/issue-80853.stderr b/tests/ui/structs/issue-80853.stderr
index 1c7d52b6d60..9930efab730 100644
--- a/tests/ui/structs/issue-80853.stderr
+++ b/tests/ui/structs/issue-80853.stderr
@@ -8,6 +8,6 @@ LL |     thing();
    |     |
    |     call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/structs/method-chain-expression-failure.stderr b/tests/ui/structs/method-chain-expression-failure.stderr
index ba635ab1fe6..a0bcef6b031 100644
--- a/tests/ui/structs/method-chain-expression-failure.stderr
+++ b/tests/ui/structs/method-chain-expression-failure.stderr
@@ -10,6 +10,6 @@ LL |     A.b().c().d().e().foo();
    |     |     method `foo` is available on `&C`
    |     method `foo` is available on `&A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/structs/multi-line-fru-suggestion.stderr b/tests/ui/structs/multi-line-fru-suggestion.stderr
index 8bbd3ace7d2..5b4b532fcaa 100644
--- a/tests/ui/structs/multi-line-fru-suggestion.stderr
+++ b/tests/ui/structs/multi-line-fru-suggestion.stderr
@@ -20,6 +20,6 @@ help: to set the remaining fields from `Default::default()`, separate the last n
 LL |         }, 
    |          +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0063`.
diff --git a/tests/ui/structs/struct-duplicate-comma.stderr b/tests/ui/structs/struct-duplicate-comma.stderr
index 834b3c5c171..4ac3fc9fe6b 100644
--- a/tests/ui/structs/struct-duplicate-comma.stderr
+++ b/tests/ui/structs/struct-duplicate-comma.stderr
@@ -9,5 +9,5 @@ LL |         a: 0,,
    |              expected identifier
    |              help: remove this comma
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/structs/struct-fields-decl-dupe.stderr b/tests/ui/structs/struct-fields-decl-dupe.stderr
index d7ce9bb8922..3c25708a3de 100644
--- a/tests/ui/structs/struct-fields-decl-dupe.stderr
+++ b/tests/ui/structs/struct-fields-decl-dupe.stderr
@@ -6,6 +6,6 @@ LL |     foo: isize,
 LL |     foo: isize,
    |     ^^^^^^^^^^ field already declared
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0124`.
diff --git a/tests/ui/structs/struct-fields-dupe.stderr b/tests/ui/structs/struct-fields-dupe.stderr
index aaf2533dc01..ee38743471f 100644
--- a/tests/ui/structs/struct-fields-dupe.stderr
+++ b/tests/ui/structs/struct-fields-dupe.stderr
@@ -6,6 +6,6 @@ LL |         foo: 0,
 LL |         foo: 0
    |         ^^^ used more than once
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0062`.
diff --git a/tests/ui/structs/struct-fields-hints-no-dupe.stderr b/tests/ui/structs/struct-fields-hints-no-dupe.stderr
index e109980e0bb..2b88d802833 100644
--- a/tests/ui/structs/struct-fields-hints-no-dupe.stderr
+++ b/tests/ui/structs/struct-fields-hints-no-dupe.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |         barr : 42,
    |         ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/structs/struct-fields-hints.stderr b/tests/ui/structs/struct-fields-hints.stderr
index ed3650e5298..8217d7a6e81 100644
--- a/tests/ui/structs/struct-fields-hints.stderr
+++ b/tests/ui/structs/struct-fields-hints.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |         car : 42,
    |         ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/structs/struct-fields-missing.stderr b/tests/ui/structs/struct-fields-missing.stderr
index b3e42a94809..eba095fd35a 100644
--- a/tests/ui/structs/struct-fields-missing.stderr
+++ b/tests/ui/structs/struct-fields-missing.stderr
@@ -4,6 +4,6 @@ error[E0063]: missing field `bar` in initializer of `BuildData`
 LL |     let foo = BuildData {
    |               ^^^^^^^^^ missing `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0063`.
diff --git a/tests/ui/structs/struct-fields-shorthand-unresolved.stderr b/tests/ui/structs/struct-fields-shorthand-unresolved.stderr
index 09fc4f7ee58..b485c17c1b2 100644
--- a/tests/ui/structs/struct-fields-shorthand-unresolved.stderr
+++ b/tests/ui/structs/struct-fields-shorthand-unresolved.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `y` in this scope
 LL |         y
    |         ^ help: a local variable with a similar name exists: `x`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/structs/struct-fields-shorthand.stderr b/tests/ui/structs/struct-fields-shorthand.stderr
index d89d45b3903..c4d804aaf9d 100644
--- a/tests/ui/structs/struct-fields-shorthand.stderr
+++ b/tests/ui/structs/struct-fields-shorthand.stderr
@@ -6,6 +6,6 @@ LL |         x, y, z
    |
    = note: all struct fields are already assigned
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/structs/struct-fields-too-many.stderr b/tests/ui/structs/struct-fields-too-many.stderr
index 9342607ebce..838917474e6 100644
--- a/tests/ui/structs/struct-fields-too-many.stderr
+++ b/tests/ui/structs/struct-fields-too-many.stderr
@@ -6,6 +6,6 @@ LL |         bar: 0
    |
    = note: all struct fields are already assigned
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0560`.
diff --git a/tests/ui/structs/struct-fields-typo.stderr b/tests/ui/structs/struct-fields-typo.stderr
index aef0e0e8e5c..d87bace7277 100644
--- a/tests/ui/structs/struct-fields-typo.stderr
+++ b/tests/ui/structs/struct-fields-typo.stderr
@@ -9,6 +9,6 @@ help: a field with a similar name exists
 LL |     let x = foo.bar;
    |                 ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/structs/struct-missing-comma.stderr b/tests/ui/structs/struct-missing-comma.stderr
index eceec65e763..4fdd47a4806 100644
--- a/tests/ui/structs/struct-missing-comma.stderr
+++ b/tests/ui/structs/struct-missing-comma.stderr
@@ -4,5 +4,5 @@ error: expected `,`, or `}`, found keyword `pub`
 LL |     pub foo: u32
    |                 ^ help: try adding a comma: `,`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/structs/struct-path-alias-bounds.stderr b/tests/ui/structs/struct-path-alias-bounds.stderr
index 5b01208c56f..621496bb430 100644
--- a/tests/ui/structs/struct-path-alias-bounds.stderr
+++ b/tests/ui/structs/struct-path-alias-bounds.stderr
@@ -15,6 +15,6 @@ LL + #[derive(Clone)]
 LL | struct NoClone;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/structs/unresolved-struct-with-fru.stderr b/tests/ui/structs/unresolved-struct-with-fru.stderr
index a5796a22225..9902c3ed357 100644
--- a/tests/ui/structs/unresolved-struct-with-fru.stderr
+++ b/tests/ui/structs/unresolved-struct-with-fru.stderr
@@ -4,6 +4,6 @@ error[E0422]: cannot find struct, variant or union type `Oops` in this scope
 LL |         let s2 = Oops { a: 2, ..s1 };
    |                  ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0422`.
diff --git a/tests/ui/suggestions/abi-typo.stderr b/tests/ui/suggestions/abi-typo.stderr
index 67a84f119f6..ea474e32125 100644
--- a/tests/ui/suggestions/abi-typo.stderr
+++ b/tests/ui/suggestions/abi-typo.stderr
@@ -9,6 +9,6 @@ LL | extern "cdedl" fn cdedl() {}
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions.
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0703`.
diff --git a/tests/ui/suggestions/as-ref-2.stderr b/tests/ui/suggestions/as-ref-2.stderr
index e2129b4502a..5432fcb1a58 100644
--- a/tests/ui/suggestions/as-ref-2.stderr
+++ b/tests/ui/suggestions/as-ref-2.stderr
@@ -13,6 +13,6 @@ LL |     let _y = foo;
 note: `Option::<T>::map` takes ownership of the receiver `self`, which moves `foo`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/suggestions/assoc-const-as-field.stderr b/tests/ui/suggestions/assoc-const-as-field.stderr
index 78e5634b2de..0f58ce65049 100644
--- a/tests/ui/suggestions/assoc-const-as-field.stderr
+++ b/tests/ui/suggestions/assoc-const-as-field.stderr
@@ -4,6 +4,6 @@ error[E0423]: expected value, found struct `Mod::Foo`
 LL |     foo(Mod::Foo.Bar);
    |         ^^^^^^^^- help: use the path separator to refer to an item: `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/suggestions/assoc-const-as-fn.stderr b/tests/ui/suggestions/assoc-const-as-fn.stderr
index d55d968b600..69e9af72647 100644
--- a/tests/ui/suggestions/assoc-const-as-fn.stderr
+++ b/tests/ui/suggestions/assoc-const-as-fn.stderr
@@ -9,6 +9,6 @@ help: consider further restricting this bound
 LL | pub fn foo<T: UniformScalar + GlUniformScalar>(value: T) {
    |                             +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/assoc-const-without-self.stderr b/tests/ui/suggestions/assoc-const-without-self.stderr
index 05528d277be..5a9fba8a0e4 100644
--- a/tests/ui/suggestions/assoc-const-without-self.stderr
+++ b/tests/ui/suggestions/assoc-const-without-self.stderr
@@ -9,6 +9,6 @@ help: consider using the associated constant on `Self`
 LL |         Self::A_CONST
    |         ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/suggestions/assoc-type-in-method-return.stderr b/tests/ui/suggestions/assoc-type-in-method-return.stderr
index df3828ad411..f83da790970 100644
--- a/tests/ui/suggestions/assoc-type-in-method-return.stderr
+++ b/tests/ui/suggestions/assoc-type-in-method-return.stderr
@@ -9,6 +9,6 @@ help: you might have meant to use the associated type
 LL |     fn to_bla(&self) -> Self::Bla;
    |                         ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/suggestions/bad-infer-in-trait-impl.stderr b/tests/ui/suggestions/bad-infer-in-trait-impl.stderr
index 418690ff85f..d96ee33a914 100644
--- a/tests/ui/suggestions/bad-infer-in-trait-impl.stderr
+++ b/tests/ui/suggestions/bad-infer-in-trait-impl.stderr
@@ -9,6 +9,6 @@ help: use type parameters instead
 LL |     fn bar<T>(s: T) {}
    |           +++    ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/suggestions/box-future-wrong-output.stderr b/tests/ui/suggestions/box-future-wrong-output.stderr
index e0c57af25b3..6a232c3444d 100644
--- a/tests/ui/suggestions/box-future-wrong-output.stderr
+++ b/tests/ui/suggestions/box-future-wrong-output.stderr
@@ -9,6 +9,6 @@ LL |     let _: BoxFuture<'static, bool> = async {}.boxed();
    = note: expected struct `Pin<Box<(dyn Future<Output = bool> + Send + 'static)>>`
               found struct `Pin<Box<dyn Future<Output = ()> + Send>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/boxed-variant-field.stderr b/tests/ui/suggestions/boxed-variant-field.stderr
index 1adbc05406c..c5fe9630b9b 100644
--- a/tests/ui/suggestions/boxed-variant-field.stderr
+++ b/tests/ui/suggestions/boxed-variant-field.stderr
@@ -18,6 +18,6 @@ help: consider unboxing the value
 LL |         Ty::List(elem) => foo(*elem),
    |                               +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/call-boxed.stderr b/tests/ui/suggestions/call-boxed.stderr
index 11823ff09d3..08fa1a698d6 100644
--- a/tests/ui/suggestions/call-boxed.stderr
+++ b/tests/ui/suggestions/call-boxed.stderr
@@ -15,6 +15,6 @@ help: use parentheses to call this closure
 LL |     x = y();
    |          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/call-on-unimplemented-ctor.stderr b/tests/ui/suggestions/call-on-unimplemented-ctor.stderr
index 58612cbfb23..4124a006172 100644
--- a/tests/ui/suggestions/call-on-unimplemented-ctor.stderr
+++ b/tests/ui/suggestions/call-on-unimplemented-ctor.stderr
@@ -16,6 +16,6 @@ help: use parentheses to construct this tuple struct
 LL |     insert_resource(Time(/* u32 */));
    |                         +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/call-on-unimplemented-fn-ptr.stderr b/tests/ui/suggestions/call-on-unimplemented-fn-ptr.stderr
index 167f7e592a9..f20596a80a6 100644
--- a/tests/ui/suggestions/call-on-unimplemented-fn-ptr.stderr
+++ b/tests/ui/suggestions/call-on-unimplemented-fn-ptr.stderr
@@ -16,6 +16,6 @@ help: use parentheses to call this function pointer
 LL |     needs_bar(f());
    |                ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/call-on-unimplemented-with-autoderef.stderr b/tests/ui/suggestions/call-on-unimplemented-with-autoderef.stderr
index 90f44cce06e..f804c66aafe 100644
--- a/tests/ui/suggestions/call-on-unimplemented-with-autoderef.stderr
+++ b/tests/ui/suggestions/call-on-unimplemented-with-autoderef.stderr
@@ -16,6 +16,6 @@ help: use parentheses to call this trait object
 LL |     needs_foo(x());
    |                ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/const-in-struct-pat.stderr b/tests/ui/suggestions/const-in-struct-pat.stderr
index f344ac06db1..d4056e09cc3 100644
--- a/tests/ui/suggestions/const-in-struct-pat.stderr
+++ b/tests/ui/suggestions/const-in-struct-pat.stderr
@@ -15,6 +15,6 @@ help: bind the struct field to a different name instead
 LL |     let Thing { foo: other_foo } = t;
    |                    +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/const-pat-non-exaustive-let-new-var.stderr b/tests/ui/suggestions/const-pat-non-exaustive-let-new-var.stderr
index 9ee3e6eb2c8..b6c28612802 100644
--- a/tests/ui/suggestions/const-pat-non-exaustive-let-new-var.stderr
+++ b/tests/ui/suggestions/const-pat-non-exaustive-let-new-var.stderr
@@ -12,6 +12,6 @@ LL |     let A = 3;
    = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
    = note: the matched value is of type `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/suggestions/constrain-suggest-ice.stderr b/tests/ui/suggestions/constrain-suggest-ice.stderr
index 9b92091de9f..96f1f860588 100644
--- a/tests/ui/suggestions/constrain-suggest-ice.stderr
+++ b/tests/ui/suggestions/constrain-suggest-ice.stderr
@@ -9,5 +9,5 @@ LL |     A: [(); {
 LL | }
    | ^ mismatched closing delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/core-std-import-order-issue-83564.stderr b/tests/ui/suggestions/core-std-import-order-issue-83564.stderr
index 48ee44a74f2..c2634e3070e 100644
--- a/tests/ui/suggestions/core-std-import-order-issue-83564.stderr
+++ b/tests/ui/suggestions/core-std-import-order-issue-83564.stderr
@@ -11,6 +11,6 @@ LL + use core::num::NonZeroU32;
 LL + use std::num::NonZeroU32;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/suggestions/correct-binder-for-arbitrary-bound-sugg.stderr b/tests/ui/suggestions/correct-binder-for-arbitrary-bound-sugg.stderr
index 2298e7f4e0c..2cd3fba8715 100644
--- a/tests/ui/suggestions/correct-binder-for-arbitrary-bound-sugg.stderr
+++ b/tests/ui/suggestions/correct-binder-for-arbitrary-bound-sugg.stderr
@@ -17,6 +17,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn foo<T: Foo>() where for<'a> &'a T: Bar {}
    |                  ++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/deref-path-method.stderr b/tests/ui/suggestions/deref-path-method.stderr
index 0372a7e6cc0..a2b68fa966f 100644
--- a/tests/ui/suggestions/deref-path-method.stderr
+++ b/tests/ui/suggestions/deref-path-method.stderr
@@ -16,6 +16,6 @@ help: the function `contains` is implemented on `[_]`
 LL |     <[_]>::contains(&vec, &0);
    |     ~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/derive-clone-for-eq.stderr b/tests/ui/suggestions/derive-clone-for-eq.stderr
index 9d843c2514b..eb95f729d1e 100644
--- a/tests/ui/suggestions/derive-clone-for-eq.stderr
+++ b/tests/ui/suggestions/derive-clone-for-eq.stderr
@@ -19,6 +19,6 @@ help: consider restricting type parameter `T`
 LL | pub struct Struct<T: std::clone::Clone>(T);
    |                    +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/dont-suggest-deref-inside-macro-issue-58298.stderr b/tests/ui/suggestions/dont-suggest-deref-inside-macro-issue-58298.stderr
index c6867270ad8..46613e8e1b4 100644
--- a/tests/ui/suggestions/dont-suggest-deref-inside-macro-issue-58298.stderr
+++ b/tests/ui/suggestions/dont-suggest-deref-inside-macro-issue-58298.stderr
@@ -8,6 +8,6 @@ LL | |     };
    |
    = note: this error originates in the macro `format` which comes from the expansion of the macro `intrinsic_match` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-child.stderr b/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-child.stderr
index 866d3fab46e..00d001f6bee 100644
--- a/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-child.stderr
+++ b/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-child.stderr
@@ -13,6 +13,6 @@ help: try wrapping the expression in `hidden_child::__private::Some`
 LL |     let x: Option<i32> = hidden_child::__private::Some(1i32);
    |                          ++++++++++++++++++++++++++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-parent.stderr b/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-parent.stderr
index f8029e452bb..ef08282702e 100644
--- a/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-parent.stderr
+++ b/tests/ui/suggestions/dont-suggest-doc-hidden-variant-for-enum/hidden-parent.stderr
@@ -13,6 +13,6 @@ help: try wrapping the expression in `Some`
 LL |     let x: Option<i32> = Some(1i32);
    |                          +++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/dont-suggest-pin-array-dot-set.stderr b/tests/ui/suggestions/dont-suggest-pin-array-dot-set.stderr
index c66da3ea6d9..8f738465d38 100644
--- a/tests/ui/suggestions/dont-suggest-pin-array-dot-set.stderr
+++ b/tests/ui/suggestions/dont-suggest-pin-array-dot-set.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `set` found for array `[u8; 1]` in the current sco
 LL |     a.set(0, 3);
    |       ^^^ help: there is a method with a similar name: `get`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/dont-suggest-try_into-in-macros.stderr b/tests/ui/suggestions/dont-suggest-try_into-in-macros.stderr
index 319d866003b..348f7e00d46 100644
--- a/tests/ui/suggestions/dont-suggest-try_into-in-macros.stderr
+++ b/tests/ui/suggestions/dont-suggest-try_into-in-macros.stderr
@@ -9,6 +9,6 @@ help: change the type of the numeric literal from `usize` to `u64`
 LL |     assert_eq!(10u64, 10u64);
    |                         ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/dont-suggest-ufcs-for-const.stderr b/tests/ui/suggestions/dont-suggest-ufcs-for-const.stderr
index 0d9543e0b8f..6aa187bfbd3 100644
--- a/tests/ui/suggestions/dont-suggest-ufcs-for-const.stderr
+++ b/tests/ui/suggestions/dont-suggest-ufcs-for-const.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `MAX` found for type `u32` in the current scope
 LL |     1_u32.MAX();
    |           ^^^ method not found in `u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/dont-wrap-ambiguous-receivers.stderr b/tests/ui/suggestions/dont-wrap-ambiguous-receivers.stderr
index 85fbb8b88e8..974aedd13cf 100644
--- a/tests/ui/suggestions/dont-wrap-ambiguous-receivers.stderr
+++ b/tests/ui/suggestions/dont-wrap-ambiguous-receivers.stderr
@@ -15,6 +15,6 @@ LL + use banana::Apple;
 LL + use banana::Peach;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/enum-variant-arg-mismatch.stderr b/tests/ui/suggestions/enum-variant-arg-mismatch.stderr
index f76019b7000..6d72dabf70e 100644
--- a/tests/ui/suggestions/enum-variant-arg-mismatch.stderr
+++ b/tests/ui/suggestions/enum-variant-arg-mismatch.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `map`
 LL | fn map<'a, F: Fn(String) -> Sexpr<'a>>(f: F) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `map`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/suggestions/field-access-considering-privacy.stderr b/tests/ui/suggestions/field-access-considering-privacy.stderr
index cbf6f3d1002..2b1f4592383 100644
--- a/tests/ui/suggestions/field-access-considering-privacy.stderr
+++ b/tests/ui/suggestions/field-access-considering-privacy.stderr
@@ -9,6 +9,6 @@ help: one of the expressions' fields has a field of the same name
 LL |         tcx.sess.opts;
    |             +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/suggestions/field-has-method.stderr b/tests/ui/suggestions/field-has-method.stderr
index def16401750..daff2db6418 100644
--- a/tests/ui/suggestions/field-has-method.stderr
+++ b/tests/ui/suggestions/field-has-method.stderr
@@ -12,6 +12,6 @@ help: one of the expressions' fields has a method of the same name
 LL |     let k = i.value.kind();
    |               ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/fn-needing-specified-return-type-param.stderr b/tests/ui/suggestions/fn-needing-specified-return-type-param.stderr
index 9dea667fb96..47a7ac895bf 100644
--- a/tests/ui/suggestions/fn-needing-specified-return-type-param.stderr
+++ b/tests/ui/suggestions/fn-needing-specified-return-type-param.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     let _ = f::<A>;
    |              +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/suggestions/imm-ref-trait-object-literal-bound-regions.stderr b/tests/ui/suggestions/imm-ref-trait-object-literal-bound-regions.stderr
index fc5a521746a..2733bbff36b 100644
--- a/tests/ui/suggestions/imm-ref-trait-object-literal-bound-regions.stderr
+++ b/tests/ui/suggestions/imm-ref-trait-object-literal-bound-regions.stderr
@@ -17,6 +17,6 @@ LL | where
 LL |     for<'b> &'b X: Trait,
    |                    ^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/imm-ref-trait-object.stderr b/tests/ui/suggestions/imm-ref-trait-object.stderr
index f7f7902c17d..6cd21fcabfa 100644
--- a/tests/ui/suggestions/imm-ref-trait-object.stderr
+++ b/tests/ui/suggestions/imm-ref-trait-object.stderr
@@ -9,5 +9,5 @@ help: you need `&mut dyn Iterator<Item = &u64>` instead of `&dyn Iterator<Item =
 LL | fn test(t: &mut dyn Iterator<Item=&u64>) -> u64 {
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/impl-trait-with-missing-trait-bounds-in-arg.stderr b/tests/ui/suggestions/impl-trait-with-missing-trait-bounds-in-arg.stderr
index 20f8e65f769..3a6052448cb 100644
--- a/tests/ui/suggestions/impl-trait-with-missing-trait-bounds-in-arg.stderr
+++ b/tests/ui/suggestions/impl-trait-with-missing-trait-bounds-in-arg.stderr
@@ -12,6 +12,6 @@ help: the following trait defines an item `hello`, perhaps you need to restrict
 LL | fn test(foo: impl Foo + Bar) {
    |                       +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/into-str.stderr b/tests/ui/suggestions/into-str.stderr
index 7e24150e7f4..d6efc8173cb 100644
--- a/tests/ui/suggestions/into-str.stderr
+++ b/tests/ui/suggestions/into-str.stderr
@@ -21,6 +21,6 @@ note: required by a bound in `foo`
 LL | fn foo<'a, T>(_t: T) where T: Into<&'a str> {}
    |                               ^^^^^^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/invalid-bin-op.stderr b/tests/ui/suggestions/invalid-bin-op.stderr
index 570afcea643..018250c8c1b 100644
--- a/tests/ui/suggestions/invalid-bin-op.stderr
+++ b/tests/ui/suggestions/invalid-bin-op.stderr
@@ -21,6 +21,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | pub fn foo<T>(s: S<T>, t: S<T>) where S<T>: PartialEq {
    |                                 +++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/suggestions/issue-101065.stderr b/tests/ui/suggestions/issue-101065.stderr
index 9f77ead4294..8a7ecc80178 100644
--- a/tests/ui/suggestions/issue-101065.stderr
+++ b/tests/ui/suggestions/issue-101065.stderr
@@ -18,6 +18,6 @@ help: try wrapping the expression in `FakeResult::Ok`
 LL |         FakeResult::Ok(FakeResult::Ok(()))
    |         +++++++++++++++                  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-101421.stderr b/tests/ui/suggestions/issue-101421.stderr
index 2656ab3db0b..ececba5fb1b 100644
--- a/tests/ui/suggestions/issue-101421.stderr
+++ b/tests/ui/suggestions/issue-101421.stderr
@@ -12,6 +12,6 @@ note: method defined here, with 0 generic parameters
 LL |     fn f(&self, _: ());
    |        ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/suggestions/issue-101465.stderr b/tests/ui/suggestions/issue-101465.stderr
index 2aec3c863af..0dad813b389 100644
--- a/tests/ui/suggestions/issue-101465.stderr
+++ b/tests/ui/suggestions/issue-101465.stderr
@@ -20,6 +20,6 @@ LL ~         true => Box::new(B),
 LL ~         false => Box::new(C),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-101623.stderr b/tests/ui/suggestions/issue-101623.stderr
index 9f00de17484..4de91a1b995 100644
--- a/tests/ui/suggestions/issue-101623.stderr
+++ b/tests/ui/suggestions/issue-101623.stderr
@@ -10,6 +10,6 @@ LL |     Trait::do_stuff({ fun(&mut *inner) });
    = help: the trait `Trait<'_>` is implemented for `()`
    = help: for that trait implementation, expected `()`, found `*mut ()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-101984.stderr b/tests/ui/suggestions/issue-101984.stderr
index 151587d4222..c19cda20402 100644
--- a/tests/ui/suggestions/issue-101984.stderr
+++ b/tests/ui/suggestions/issue-101984.stderr
@@ -9,6 +9,6 @@ LL |         let (cmp, router) = self.router.at()?;
    = note: expected struct `Match<&(for<'a> fn(&'a ()), Box<Wrapper>)>`
                found tuple `(_, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-102354.stderr b/tests/ui/suggestions/issue-102354.stderr
index 08d4b995590..8340d9340f9 100644
--- a/tests/ui/suggestions/issue-102354.stderr
+++ b/tests/ui/suggestions/issue-102354.stderr
@@ -14,6 +14,6 @@ note: the candidate is defined in the trait `Trait`
 LL |     fn func() {}
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/issue-103112.stderr b/tests/ui/suggestions/issue-103112.stderr
index 4ca7fdf9b5a..b7de57bfd90 100644
--- a/tests/ui/suggestions/issue-103112.stderr
+++ b/tests/ui/suggestions/issue-103112.stderr
@@ -10,6 +10,6 @@ LL -     std::process::abort!();
 LL +     std::process::abort();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/suggestions/issue-103646.stderr b/tests/ui/suggestions/issue-103646.stderr
index 3ae9813d491..8d0e8652392 100644
--- a/tests/ui/suggestions/issue-103646.stderr
+++ b/tests/ui/suggestions/issue-103646.stderr
@@ -16,6 +16,6 @@ note: the candidate is defined in the trait `Cat`
 LL |     fn nya() {}
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/issue-104327.stderr b/tests/ui/suggestions/issue-104327.stderr
index acec3a55d52..325b6b6eb4b 100644
--- a/tests/ui/suggestions/issue-104327.stderr
+++ b/tests/ui/suggestions/issue-104327.stderr
@@ -12,6 +12,6 @@ help: use the fully-qualified path to the only available implementation
 LL |     <(dyn Bar + 'static) as Foo>::f();
    |     +++++++++++++++++++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/suggestions/issue-104328.stderr b/tests/ui/suggestions/issue-104328.stderr
index b31b84781ba..a5926218341 100644
--- a/tests/ui/suggestions/issue-104328.stderr
+++ b/tests/ui/suggestions/issue-104328.stderr
@@ -12,6 +12,6 @@ help: use the fully-qualified path to the only available implementation
 LL |     <(dyn Sized + 'static) as Foo>::f();
    |     +++++++++++++++++++++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/suggestions/issue-105645.stderr b/tests/ui/suggestions/issue-105645.stderr
index 895f5ffd1e1..f717f8f4e65 100644
--- a/tests/ui/suggestions/issue-105645.stderr
+++ b/tests/ui/suggestions/issue-105645.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `foo`
 LL | fn foo(_: &mut impl std::io::Write) {}
    |                     ^^^^^^^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-107860.stderr b/tests/ui/suggestions/issue-107860.stderr
index 92e3cf8c43b..4be495da46b 100644
--- a/tests/ui/suggestions/issue-107860.stderr
+++ b/tests/ui/suggestions/issue-107860.stderr
@@ -7,6 +7,6 @@ LL | async fn str<T>(T: &str) -> &str { &str }
    = note: expected reference `&str`
               found reference `&for<'a> fn(&'a str) -> impl Future<Output = &'a str> {str::<_>}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-109291.stderr b/tests/ui/suggestions/issue-109291.stderr
index 644841fdf7e..c787be4de7c 100644
--- a/tests/ui/suggestions/issue-109291.stderr
+++ b/tests/ui/suggestions/issue-109291.stderr
@@ -14,6 +14,6 @@ note: if you're trying to build a new `Backtrace` consider using one of the foll
       Backtrace::create
   --> $SRC_DIR/std/src/backtrace.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/issue-109436.stderr b/tests/ui/suggestions/issue-109436.stderr
index c479326f935..4425ce84b6d 100644
--- a/tests/ui/suggestions/issue-109436.stderr
+++ b/tests/ui/suggestions/issue-109436.stderr
@@ -10,6 +10,6 @@ help: consider borrowing here
 LL |     let b: Bar = (&foo).into();
    |                  ++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-109854.stderr b/tests/ui/suggestions/issue-109854.stderr
index 621a3897165..52444cd4c45 100644
--- a/tests/ui/suggestions/issue-109854.stderr
+++ b/tests/ui/suggestions/issue-109854.stderr
@@ -26,6 +26,6 @@ LL -     generate_setter,
 LL +     /* usize */,
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/suggestions/issue-114701.stderr b/tests/ui/suggestions/issue-114701.stderr
index 67462a09c78..d2a7806b7c1 100644
--- a/tests/ui/suggestions/issue-114701.stderr
+++ b/tests/ui/suggestions/issue-114701.stderr
@@ -10,6 +10,6 @@ LL |         assert!(if let Enum::$variant::<()> $matcher = $expr () { true } el
 LL |     is_variant!(UVariant, Enum::<()>::UVariant);
    |                           ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/suggestions/issue-117669.stderr b/tests/ui/suggestions/issue-117669.stderr
index f09675fcc5c..01783ea4ef6 100644
--- a/tests/ui/suggestions/issue-117669.stderr
+++ b/tests/ui/suggestions/issue-117669.stderr
@@ -13,6 +13,6 @@ help: consider using `Option::expect` to unwrap the `Option<i32>` value, panicki
 LL |     let abs: i32 = 3i32.checked_abs().expect("REASON");
    |                                      +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-51055-missing-semicolon-between-call-and-tuple.stderr b/tests/ui/suggestions/issue-51055-missing-semicolon-between-call-and-tuple.stderr
index bb8b9b37067..3c3bc2305e0 100644
--- a/tests/ui/suggestions/issue-51055-missing-semicolon-between-call-and-tuple.stderr
+++ b/tests/ui/suggestions/issue-51055-missing-semicolon-between-call-and-tuple.stderr
@@ -11,6 +11,6 @@ LL |       vindictive()
 LL | |     (1, 2)
    | |__________- call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/suggestions/issue-61226.stderr b/tests/ui/suggestions/issue-61226.stderr
index cda962a9045..890950b1ae9 100644
--- a/tests/ui/suggestions/issue-61226.stderr
+++ b/tests/ui/suggestions/issue-61226.stderr
@@ -7,6 +7,6 @@ LL | fn main() {
 LL |     let _ = vec![X]; //…
    |                  ^ help: use struct literal syntax instead: `X {}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/suggestions/issue-62843.stderr b/tests/ui/suggestions/issue-62843.stderr
index ead8f18547b..f3a9f6b7913 100644
--- a/tests/ui/suggestions/issue-62843.stderr
+++ b/tests/ui/suggestions/issue-62843.stderr
@@ -15,6 +15,6 @@ help: consider borrowing here
 LL |     println!("{:?}", line.find(&pattern));
    |                                +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-66968-suggest-sorted-words.stderr b/tests/ui/suggestions/issue-66968-suggest-sorted-words.stderr
index d7b33ea41f7..ce0087fbfcb 100644
--- a/tests/ui/suggestions/issue-66968-suggest-sorted-words.stderr
+++ b/tests/ui/suggestions/issue-66968-suggest-sorted-words.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find value `a_variable_longer_name` in this scope
 LL |     println!("{}", a_variable_longer_name);
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: a local variable with a similar name exists: `a_longer_variable_name`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/suggestions/issue-68049-1.stderr b/tests/ui/suggestions/issue-68049-1.stderr
index 7f931f0cdc9..760f83d548f 100644
--- a/tests/ui/suggestions/issue-68049-1.stderr
+++ b/tests/ui/suggestions/issue-68049-1.stderr
@@ -4,6 +4,6 @@ error[E0594]: cannot assign to `self.0`, which is behind a `&` reference
 LL |         self.0 += 1;
    |         ^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/suggestions/issue-71394-no-from-impl.stderr b/tests/ui/suggestions/issue-71394-no-from-impl.stderr
index 80be252a0a5..235dfcd3a2a 100644
--- a/tests/ui/suggestions/issue-71394-no-from-impl.stderr
+++ b/tests/ui/suggestions/issue-71394-no-from-impl.stderr
@@ -16,6 +16,6 @@ LL |     let _: &[i8] = data.into();
            and 6 others
    = note: required for `&[u8]` to implement `Into<&[i8]>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-72766.stderr b/tests/ui/suggestions/issue-72766.stderr
index f257bb9b0e8..f0680dfe19f 100644
--- a/tests/ui/suggestions/issue-72766.stderr
+++ b/tests/ui/suggestions/issue-72766.stderr
@@ -10,6 +10,6 @@ help: consider `await`ing on the `Future`
 LL |     SadGirl {}.call().await?;
    |                      ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-81839.stderr b/tests/ui/suggestions/issue-81839.stderr
index 238ee637c7d..de1ea98554b 100644
--- a/tests/ui/suggestions/issue-81839.stderr
+++ b/tests/ui/suggestions/issue-81839.stderr
@@ -21,6 +21,6 @@ help: consider using a semicolon here, but this will discard any values in the m
 LL |     };
    |      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-83892.stderr b/tests/ui/suggestions/issue-83892.stderr
index 5e471819b27..7dbffcfca4e 100644
--- a/tests/ui/suggestions/issue-83892.stderr
+++ b/tests/ui/suggestions/issue-83892.stderr
@@ -9,6 +9,6 @@ LL |         () => func()
 LL |     }
    |      - help: consider using a semicolon here: `;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-83943.stderr b/tests/ui/suggestions/issue-83943.stderr
index c73667f09cb..1a085368485 100644
--- a/tests/ui/suggestions/issue-83943.stderr
+++ b/tests/ui/suggestions/issue-83943.stderr
@@ -12,6 +12,6 @@ LL | |         "B"
 LL | |     };
    | |_____- `if` and `else` have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-84592.stderr b/tests/ui/suggestions/issue-84592.stderr
index 70c96feb1de..fe0a7b6731e 100644
--- a/tests/ui/suggestions/issue-84592.stderr
+++ b/tests/ui/suggestions/issue-84592.stderr
@@ -12,6 +12,6 @@ help: consider introducing a named lifetime parameter
 LL | fn two_lifetimes_needed<'a>(a: &'a (), b: &'a ()) -> TwoLifetimes<'a, 'a> {
    |                        ++++     ++         ++                     ~~  ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/suggestions/issue-84973-2.stderr b/tests/ui/suggestions/issue-84973-2.stderr
index 513bf28fb58..74995a0500a 100644
--- a/tests/ui/suggestions/issue-84973-2.stderr
+++ b/tests/ui/suggestions/issue-84973-2.stderr
@@ -16,6 +16,6 @@ help: consider mutably borrowing here
 LL |     foo(&mut a);
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-84973.stderr b/tests/ui/suggestions/issue-84973.stderr
index 55c89884a5f..c5e1958e030 100644
--- a/tests/ui/suggestions/issue-84973.stderr
+++ b/tests/ui/suggestions/issue-84973.stderr
@@ -19,6 +19,6 @@ help: consider borrowing here
 LL |     let o = Other::new(&f);
    |                        +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-85943-no-suggest-unsized-indirection-in-where-clause.stderr b/tests/ui/suggestions/issue-85943-no-suggest-unsized-indirection-in-where-clause.stderr
index 752533cdc12..21b568b02ad 100644
--- a/tests/ui/suggestions/issue-85943-no-suggest-unsized-indirection-in-where-clause.stderr
+++ b/tests/ui/suggestions/issue-85943-no-suggest-unsized-indirection-in-where-clause.stderr
@@ -18,6 +18,6 @@ LL | struct A<T>(T) where T: Send;
    |          |
    |          this could be changed to `T: ?Sized`...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-85945-check-where-clause-before-suggesting-unsized.stderr b/tests/ui/suggestions/issue-85945-check-where-clause-before-suggesting-unsized.stderr
index 92be9f764cc..77e5dcd91a1 100644
--- a/tests/ui/suggestions/issue-85945-check-where-clause-before-suggesting-unsized.stderr
+++ b/tests/ui/suggestions/issue-85945-check-where-clause-before-suggesting-unsized.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `foo`
 LL | fn foo<T>(_: &T) where T: Sized {}
    |        ^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-88696.stderr b/tests/ui/suggestions/issue-88696.stderr
index 4947269d759..b4f0793c225 100644
--- a/tests/ui/suggestions/issue-88696.stderr
+++ b/tests/ui/suggestions/issue-88696.stderr
@@ -6,6 +6,6 @@ LL |     a().into()
    |
    = note: required for `Result<u64, i32>` to implement `Into<Result<u32, i32>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-89333.stderr b/tests/ui/suggestions/issue-89333.stderr
index 4739f11ddad..761de7f2521 100644
--- a/tests/ui/suggestions/issue-89333.stderr
+++ b/tests/ui/suggestions/issue-89333.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `test`
 LL | fn test<T>(arg: &impl Fn() -> T) where for<'a> &'a T: Trait {}
    |                                                       ^^^^^ required by this bound in `test`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-89640.stderr b/tests/ui/suggestions/issue-89640.stderr
index 8ff4ef4f0ec..3252cd6bba4 100644
--- a/tests/ui/suggestions/issue-89640.stderr
+++ b/tests/ui/suggestions/issue-89640.stderr
@@ -9,5 +9,5 @@ help: consider removing the space to spell keyword `let`
 LL |     let x: i32 = 3;
    |     ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr b/tests/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr
index 7d1da7d24ee..96fb1f3c68d 100644
--- a/tests/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr
+++ b/tests/ui/suggestions/issue-90213-expected-boxfuture-self-ice.stderr
@@ -19,6 +19,6 @@ help: store this in the heap by calling `Box::new`
 LL |         Self::foo(Box::new(None))
    |                   +++++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/issue-90974.stderr b/tests/ui/suggestions/issue-90974.stderr
index e1fb479a3a7..1a732ecaf94 100644
--- a/tests/ui/suggestions/issue-90974.stderr
+++ b/tests/ui/suggestions/issue-90974.stderr
@@ -9,6 +9,6 @@ help: you must specify a concrete type for this numeric value, like `f32`
 LL |     println!("{}", (3_f32).recip());
    |                     ~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0689`.
diff --git a/tests/ui/suggestions/issue-96223.stderr b/tests/ui/suggestions/issue-96223.stderr
index d4e9433dfda..a54a4e7b3be 100644
--- a/tests/ui/suggestions/issue-96223.stderr
+++ b/tests/ui/suggestions/issue-96223.stderr
@@ -26,6 +26,6 @@ note: required by a bound in `icey_bounds`
 LL | fn icey_bounds<D: Dummy<EmptyMarker>>(p: &D) {}
    |                   ^^^^^^^^^^^^^^^^^^ required by this bound in `icey_bounds`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-97677.stderr b/tests/ui/suggestions/issue-97677.stderr
index 575d79267f2..0e95167d851 100644
--- a/tests/ui/suggestions/issue-97677.stderr
+++ b/tests/ui/suggestions/issue-97677.stderr
@@ -11,6 +11,6 @@ help: consider restricting type parameter `N`
 LL | fn add_ten<N: std::ops::Add<i32, Output = N>>(n: N) -> N {
    |             ++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/suggestions/issue-97704.stderr b/tests/ui/suggestions/issue-97704.stderr
index ca017be45ac..a7284db1d95 100644
--- a/tests/ui/suggestions/issue-97704.stderr
+++ b/tests/ui/suggestions/issue-97704.stderr
@@ -10,6 +10,6 @@ help: consider `await`ing on the `Future`
 LL |     func(async { Ok::<_, i32>(()) }).await?;
    |                                     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-97760.stderr b/tests/ui/suggestions/issue-97760.stderr
index 5415c247c8f..c3cf7e13987 100644
--- a/tests/ui/suggestions/issue-97760.stderr
+++ b/tests/ui/suggestions/issue-97760.stderr
@@ -13,6 +13,6 @@ LL ~ pub fn print_values<I: IntoIterator>(values: &I)
 LL ~ where <I as IntoIterator>::Item: std::fmt::Display {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-98500.stderr b/tests/ui/suggestions/issue-98500.stderr
index e7251d735e3..aa66a9aa1e7 100644
--- a/tests/ui/suggestions/issue-98500.stderr
+++ b/tests/ui/suggestions/issue-98500.stderr
@@ -19,6 +19,6 @@ LL | pub trait B where
    = help: consider moving `f` to another trait
    = help: consider moving `f2` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/suggestions/issue-98562.stderr b/tests/ui/suggestions/issue-98562.stderr
index 7897fa441a2..578eb284c26 100644
--- a/tests/ui/suggestions/issue-98562.stderr
+++ b/tests/ui/suggestions/issue-98562.stderr
@@ -6,6 +6,6 @@ LL | impl TraitA<u8, u16, u32> for X {
    |
    = help: implement the missing item: `fn baz<U: TraitC<I1 = u8, I2 = u16> + TraitD<I3 = u32>, V: TraitD<I3 = u8>>(_: U, _: V) -> Self where U: TraitE, U: TraitB, <U as TraitB>::Item: Copy { todo!() }`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/suggestions/issue-99080.stderr b/tests/ui/suggestions/issue-99080.stderr
index d1908dd9d0d..9c385a7a408 100644
--- a/tests/ui/suggestions/issue-99080.stderr
+++ b/tests/ui/suggestions/issue-99080.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `needs_meow`
 LL | fn needs_meow<T: Meow>(t: T) {}
    |                  ^^^^ required by this bound in `needs_meow`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-99240-2.stderr b/tests/ui/suggestions/issue-99240-2.stderr
index a2b55978478..00bffee6529 100644
--- a/tests/ui/suggestions/issue-99240-2.stderr
+++ b/tests/ui/suggestions/issue-99240-2.stderr
@@ -16,6 +16,6 @@ LL -     Unit();
 LL +     Unit;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/suggestions/issue-99240.stderr b/tests/ui/suggestions/issue-99240.stderr
index f1bea688b4e..ea819067a23 100644
--- a/tests/ui/suggestions/issue-99240.stderr
+++ b/tests/ui/suggestions/issue-99240.stderr
@@ -6,6 +6,6 @@ LL |     (it.0.take())()
    |     |
    |     call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/suggestions/issue-99597.stderr b/tests/ui/suggestions/issue-99597.stderr
index bdf2a07c143..e1d7aac267c 100644
--- a/tests/ui/suggestions/issue-99597.stderr
+++ b/tests/ui/suggestions/issue-99597.stderr
@@ -10,6 +10,6 @@ help: the following trait defines an item `test`, perhaps you need to restrict t
 LL | fn go(s: &(impl T1 + T2)) {
    |           +        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/js-style-comparison-op-separate-eq-token.stderr b/tests/ui/suggestions/js-style-comparison-op-separate-eq-token.stderr
index 6adefe3de37..9ef28bc2615 100644
--- a/tests/ui/suggestions/js-style-comparison-op-separate-eq-token.stderr
+++ b/tests/ui/suggestions/js-style-comparison-op-separate-eq-token.stderr
@@ -4,5 +4,5 @@ error: expected expression, found `=`
 LL |     if 1 == = 1 {
    |             ^ expected expression
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/late-bound-in-borrow-closure-sugg.stderr b/tests/ui/suggestions/late-bound-in-borrow-closure-sugg.stderr
index a03d4e8ce9f..d78de6a460c 100644
--- a/tests/ui/suggestions/late-bound-in-borrow-closure-sugg.stderr
+++ b/tests/ui/suggestions/late-bound-in-borrow-closure-sugg.stderr
@@ -21,6 +21,6 @@ help: consider adjusting the signature so it borrows its argument
 LL |     let closure = |trader : &mut Trader| {
    |                             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0631`.
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
index 6c63e1ada61..2677b7943cc 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
@@ -14,6 +14,6 @@ help: consider adding an explicit lifetime bound
 LL | fn func<'a, T: Test + 'a>(_dummy: &Foo, foo: &Foo<'a>, t: T) {
    |         +++         ++++                         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0311`.
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-before-const.stderr b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-before-const.stderr
index 7b126c90ee7..00bc43d5e46 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-before-const.stderr
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-before-const.stderr
@@ -10,6 +10,6 @@ help: consider introducing a named lifetime parameter
 LL | fn buggy_const<'a, const N: usize>(_a: &'a Option<[u8; N]>, _f: &'a str) -> &'a str {
    |                +++                      ++                       ++          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/suggestions/lifetimes/suggest-using-tick-underscore-lifetime-in-return-trait-object.stderr b/tests/ui/suggestions/lifetimes/suggest-using-tick-underscore-lifetime-in-return-trait-object.stderr
index dc5817bfe0f..73fa5ddb146 100644
--- a/tests/ui/suggestions/lifetimes/suggest-using-tick-underscore-lifetime-in-return-trait-object.stderr
+++ b/tests/ui/suggestions/lifetimes/suggest-using-tick-underscore-lifetime-in-return-trait-object.stderr
@@ -11,5 +11,5 @@ help: to declare that the trait object captures data from argument `value`, you
 LL | fn foo<T: Any>(value: &T) -> Box<dyn Any + '_> {
    |                                          ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/many-type-ascription.stderr b/tests/ui/suggestions/many-type-ascription.stderr
index e36919c82f8..feddc7d62a7 100644
--- a/tests/ui/suggestions/many-type-ascription.stderr
+++ b/tests/ui/suggestions/many-type-ascription.stderr
@@ -6,5 +6,5 @@ LL |     let _ = 0: i32;
    |
    = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/mismatched-types-numeric-from.stderr b/tests/ui/suggestions/mismatched-types-numeric-from.stderr
index 4d44d893a86..93024b1f0b1 100644
--- a/tests/ui/suggestions/mismatched-types-numeric-from.stderr
+++ b/tests/ui/suggestions/mismatched-types-numeric-from.stderr
@@ -6,6 +6,6 @@ LL |     let _: u32 = i32::from(0_u8);
    |            |
    |            expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/missing-assoc-fn-applicable-suggestions.stderr b/tests/ui/suggestions/missing-assoc-fn-applicable-suggestions.stderr
index 4c2d2776d3d..3cf5c6e7b74 100644
--- a/tests/ui/suggestions/missing-assoc-fn-applicable-suggestions.stderr
+++ b/tests/ui/suggestions/missing-assoc-fn-applicable-suggestions.stderr
@@ -9,6 +9,6 @@ LL | impl TraitA<()> for S {
    = help: implement the missing item: `fn baz<T>(_: T) -> Self where T: TraitB, <T as TraitB>::Item: Copy { todo!() }`
    = help: implement the missing item: `const A: usize = 42;`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
index 03082be690f..f9db1e1ec00 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.stderr
@@ -14,6 +14,6 @@ help: consider further restricting this bound
 LL | pub struct AABB<K: Debug + std::marker::Copy>{
    |                          +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
index 09696e0613e..ed1bde5f83e 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.stderr
@@ -18,6 +18,6 @@ help: consider further restricting this bound
 LL | pub struct AABB<K: Copy + Debug>{
    |                         +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr b/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
index 8585fe47bf3..03db737fa87 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl.stderr
@@ -18,6 +18,6 @@ help: consider restricting type parameter `K`
 LL | pub struct AABB<K: Debug>{
    |                  +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr b/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
index 856d8db381b..6dc512223d1 100644
--- a/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
+++ b/tests/ui/suggestions/missing-bound-in-manual-copy-impl-2.stderr
@@ -17,6 +17,6 @@ help: consider restricting type parameter `S`
 LL | impl<S: std::fmt::Display> Copy for Wrapper<OnlyCopyIfDisplay<S>> {}
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr b/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr
index ec3e4f23a64..fd38d4c64b4 100644
--- a/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr
+++ b/tests/ui/suggestions/missing-bound-in-manual-copy-impl.stderr
@@ -12,6 +12,6 @@ help: consider restricting type parameter `S`
 LL | impl<S: Copy> Copy for Wrapper<S> {}
    |       ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/suggestions/missing-type-param-used-in-param.stderr b/tests/ui/suggestions/missing-type-param-used-in-param.stderr
index 3116c5a0a1c..d667fc36539 100644
--- a/tests/ui/suggestions/missing-type-param-used-in-param.stderr
+++ b/tests/ui/suggestions/missing-type-param-used-in-param.stderr
@@ -16,6 +16,6 @@ help: add missing generic argument
 LL |     two_type_params::<String, _>(100);
    |                             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/suggestions/move-generic-to-trait-in-method-with-params.stderr b/tests/ui/suggestions/move-generic-to-trait-in-method-with-params.stderr
index bfdb35947ef..aa11bc7cf1d 100644
--- a/tests/ui/suggestions/move-generic-to-trait-in-method-with-params.stderr
+++ b/tests/ui/suggestions/move-generic-to-trait-in-method-with-params.stderr
@@ -19,6 +19,6 @@ LL -     1.bar::<i32>(0);
 LL +     1.bar(0);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/suggestions/no-extern-crate-in-type.stderr b/tests/ui/suggestions/no-extern-crate-in-type.stderr
index 68100e56cbc..384b17d1e2b 100644
--- a/tests/ui/suggestions/no-extern-crate-in-type.stderr
+++ b/tests/ui/suggestions/no-extern-crate-in-type.stderr
@@ -9,6 +9,6 @@ help: consider importing this struct
 LL + use foo::Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/suggestions/non-existent-field-present-in-subfield-recursion-limit.stderr b/tests/ui/suggestions/non-existent-field-present-in-subfield-recursion-limit.stderr
index b294f4da7db..278bfc60b55 100644
--- a/tests/ui/suggestions/non-existent-field-present-in-subfield-recursion-limit.stderr
+++ b/tests/ui/suggestions/non-existent-field-present-in-subfield-recursion-limit.stderr
@@ -6,6 +6,6 @@ LL |     let test = fooer.f;
    |
    = note: available fields are: `first`, `second`, `third`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/suggestions/opaque-type-error.stderr b/tests/ui/suggestions/opaque-type-error.stderr
index 5c90d3012ab..3ce45c7b674 100644
--- a/tests/ui/suggestions/opaque-type-error.stderr
+++ b/tests/ui/suggestions/opaque-type-error.stderr
@@ -24,6 +24,6 @@ LL |     } else {
 LL ~         thing_two().await
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/option-content-move-from-tuple-match.stderr b/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
index 97d05d9dcff..63314acb87c 100644
--- a/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
+++ b/tests/ui/suggestions/option-content-move-from-tuple-match.stderr
@@ -15,6 +15,6 @@ help: consider borrowing the pattern binding
 LL |         (None, &ref c) => &c.unwrap(),
    |                 +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/suggestions/option-content-move2.stderr b/tests/ui/suggestions/option-content-move2.stderr
index 94acda73c4e..0297c031ecc 100644
--- a/tests/ui/suggestions/option-content-move2.stderr
+++ b/tests/ui/suggestions/option-content-move2.stderr
@@ -15,6 +15,6 @@ LL |             var = Some(NotCopyable);
    |             variable moved due to use in closure
    |             move occurs because `var` has type `Option<NotCopyable>`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/suggestions/option-to-bool.stderr b/tests/ui/suggestions/option-to-bool.stderr
index e042f07daeb..e16d829ca7a 100644
--- a/tests/ui/suggestions/option-to-bool.stderr
+++ b/tests/ui/suggestions/option-to-bool.stderr
@@ -13,6 +13,6 @@ help: use `Option::is_some` to test if the `Option` has a value
 LL |     if true && x.is_some() {}
    |                 ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/path-by-value.stderr b/tests/ui/suggestions/path-by-value.stderr
index fd3646b8c3c..567d9d5b9e7 100644
--- a/tests/ui/suggestions/path-by-value.stderr
+++ b/tests/ui/suggestions/path-by-value.stderr
@@ -13,6 +13,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn f(p: &Path) { }
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/private-field.stderr b/tests/ui/suggestions/private-field.stderr
index 0db426588bd..0d73af03865 100644
--- a/tests/ui/suggestions/private-field.stderr
+++ b/tests/ui/suggestions/private-field.stderr
@@ -6,6 +6,6 @@ LL |     dbg!(s.cap)
    |
    = note: available field is: `val`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/suggestions/remove-question-symbol-with-paren.stderr b/tests/ui/suggestions/remove-question-symbol-with-paren.stderr
index 40b9cf2dcd4..bdea727a098 100644
--- a/tests/ui/suggestions/remove-question-symbol-with-paren.stderr
+++ b/tests/ui/suggestions/remove-question-symbol-with-paren.stderr
@@ -20,6 +20,6 @@ help: try wrapping the expression in `Some`
 LL |     (Some(x?))
    |      +++++  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/restrict-type-not-param.stderr b/tests/ui/suggestions/restrict-type-not-param.stderr
index 3c7d42888d8..6d9780a871c 100644
--- a/tests/ui/suggestions/restrict-type-not-param.stderr
+++ b/tests/ui/suggestions/restrict-type-not-param.stderr
@@ -18,6 +18,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn qux<T>(a: Wrapper<T>, b: T) -> T where Wrapper<T>: Add<T, Output = T> {
    |                                     ++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/suggestions/return-cycle-2.stderr b/tests/ui/suggestions/return-cycle-2.stderr
index 3a1a0f7f4f5..23de2309e87 100644
--- a/tests/ui/suggestions/return-cycle-2.stderr
+++ b/tests/ui/suggestions/return-cycle-2.stderr
@@ -7,6 +7,6 @@ LL |     fn as_ref(_: i32, _: i32) -> _ {
    |                                  not allowed in type signatures
    |                                  help: replace with the correct return type: `Token<&'static T>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/suggestions/return-cycle.stderr b/tests/ui/suggestions/return-cycle.stderr
index 63fa9e04087..60470490441 100644
--- a/tests/ui/suggestions/return-cycle.stderr
+++ b/tests/ui/suggestions/return-cycle.stderr
@@ -7,6 +7,6 @@ LL |     fn new() -> _ {
    |                 not allowed in type signatures
    |                 help: replace with the correct return type: `Token<()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/suggestions/shadowed-lplace-method-2.stderr b/tests/ui/suggestions/shadowed-lplace-method-2.stderr
index 2956360980e..088da83f589 100644
--- a/tests/ui/suggestions/shadowed-lplace-method-2.stderr
+++ b/tests/ui/suggestions/shadowed-lplace-method-2.stderr
@@ -20,6 +20,6 @@ help: try wrapping the expression in `X`
 LL |     *x.foo(0) = X { x: () };
    |                 ++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/shadowed-lplace-method.stderr b/tests/ui/suggestions/shadowed-lplace-method.stderr
index 33824c4cbc7..3e49716b031 100644
--- a/tests/ui/suggestions/shadowed-lplace-method.stderr
+++ b/tests/ui/suggestions/shadowed-lplace-method.stderr
@@ -21,6 +21,6 @@ help: you might have meant to call the other method; you can use the fully-quali
 LL |     *std::cell::RefCell::<_>::borrow_mut(&rc) = false;
    |      +++++++++++++++++++++++++++++++++++++  ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/silenced-binding-typo.stderr b/tests/ui/suggestions/silenced-binding-typo.stderr
index 9c0e6e26569..8dbd94208d6 100644
--- a/tests/ui/suggestions/silenced-binding-typo.stderr
+++ b/tests/ui/suggestions/silenced-binding-typo.stderr
@@ -9,6 +9,6 @@ help: a local variable with a similar name exists, consider changing it
 LL |     let x = 42;
    |         ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/suggestions/sugg-else-for-closure.stderr b/tests/ui/suggestions/sugg-else-for-closure.stderr
index 80ad3f9e41b..fda5ac4e4f0 100644
--- a/tests/ui/suggestions/sugg-else-for-closure.stderr
+++ b/tests/ui/suggestions/sugg-else-for-closure.stderr
@@ -22,6 +22,6 @@ help: try calling `unwrap_or_else` instead
 LL |     let _s = y.unwrap_or_else(|| x.split('.').nth(1).unwrap());
    |                         +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/sugg_with_positional_args_and_debug_fmt.stderr b/tests/ui/suggestions/sugg_with_positional_args_and_debug_fmt.stderr
index 850f69f2d98..be458f3bd53 100644
--- a/tests/ui/suggestions/sugg_with_positional_args_and_debug_fmt.stderr
+++ b/tests/ui/suggestions/sugg_with_positional_args_and_debug_fmt.stderr
@@ -17,5 +17,5 @@ help: use the named argument by name to avoid ambiguity
 LL |     println!("hello {world:?}", world = "world");
    |                      +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/suggest-assoc-fn-call-deref.stderr b/tests/ui/suggestions/suggest-assoc-fn-call-deref.stderr
index 00fb96f0326..a30b7869214 100644
--- a/tests/ui/suggestions/suggest-assoc-fn-call-deref.stderr
+++ b/tests/ui/suggestions/suggest-assoc-fn-call-deref.stderr
@@ -14,6 +14,6 @@ note: the candidate is defined in an impl for the type `Foo<T>`
 LL |     fn test() -> i32 { 1 }
    |     ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-placeholder.stderr b/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-placeholder.stderr
index c247e73b39c..6e4c77deac5 100644
--- a/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-placeholder.stderr
+++ b/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-placeholder.stderr
@@ -17,6 +17,6 @@ note: the candidate is defined in an impl for the type `GenericAssocMethod<T>`
 LL |     fn default_hello() {}
    |     ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-through-deref.stderr b/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-through-deref.stderr
index 7c9f0b6c212..1bc25929446 100644
--- a/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-through-deref.stderr
+++ b/tests/ui/suggestions/suggest-assoc-fn-call-with-turbofish-through-deref.stderr
@@ -14,6 +14,6 @@ note: the candidate is defined in an impl for the type `HasAssocMethod`
 LL |     fn hello() {}
    |     ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/suggestions/suggest-box.stderr b/tests/ui/suggestions/suggest-box.stderr
index e5d5ecc0be2..58f8774fe9d 100644
--- a/tests/ui/suggestions/suggest-box.stderr
+++ b/tests/ui/suggestions/suggest-box.stderr
@@ -21,6 +21,6 @@ LL |         Ok(())
 LL ~     });
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/suggest-closure-return-type-1.stderr b/tests/ui/suggestions/suggest-closure-return-type-1.stderr
index f4c2eb7ff34..be473d3cfa2 100644
--- a/tests/ui/suggestions/suggest-closure-return-type-1.stderr
+++ b/tests/ui/suggestions/suggest-closure-return-type-1.stderr
@@ -9,6 +9,6 @@ help: try giving this closure an explicit return type
 LL |     unbound_drop(|| -> [_; 0] { [] });
    |                        ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/suggestions/suggest-closure-return-type-2.stderr b/tests/ui/suggestions/suggest-closure-return-type-2.stderr
index 88bf263043d..f6c2a79b62b 100644
--- a/tests/ui/suggestions/suggest-closure-return-type-2.stderr
+++ b/tests/ui/suggestions/suggest-closure-return-type-2.stderr
@@ -9,6 +9,6 @@ help: try giving this closure an explicit return type
 LL |     unbound_drop(|| -> [_; 0] { [] })
    |                     +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/suggestions/suggest-closure-return-type-3.stderr b/tests/ui/suggestions/suggest-closure-return-type-3.stderr
index bc4107528d2..d02e20eb7b7 100644
--- a/tests/ui/suggestions/suggest-closure-return-type-3.stderr
+++ b/tests/ui/suggestions/suggest-closure-return-type-3.stderr
@@ -9,6 +9,6 @@ help: try giving this closure an explicit return type
 LL |     unbound_drop(|| -> [_; 0] { [] });
    |                     +++++++++++    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/suggestions/suggest-dereferencing-index.stderr b/tests/ui/suggestions/suggest-dereferencing-index.stderr
index 23f6657f092..2316acbe9da 100644
--- a/tests/ui/suggestions/suggest-dereferencing-index.stderr
+++ b/tests/ui/suggestions/suggest-dereferencing-index.stderr
@@ -15,6 +15,6 @@ help: dereference this index
 LL |     let one_item_please: i32 = [1, 2, 3][*i];
    |                                          +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr b/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr
index 347a038525b..bf7790e2307 100644
--- a/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr
+++ b/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr
@@ -7,6 +7,6 @@ LL | fn bar() -> _ { Wrapper(foo) }
    |             not allowed in type signatures
    |             help: replace with the correct return type: `Wrapper<fn()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/suggestions/suggest-full-enum-variant-for-local-module.stderr b/tests/ui/suggestions/suggest-full-enum-variant-for-local-module.stderr
index 3fb3047d866..866162bab01 100644
--- a/tests/ui/suggestions/suggest-full-enum-variant-for-local-module.stderr
+++ b/tests/ui/suggestions/suggest-full-enum-variant-for-local-module.stderr
@@ -13,6 +13,6 @@ help: try wrapping the expression in `option::O::Some`
 LL |     let _: option::O<()> = option::O::Some(());
    |                            ++++++++++++++++  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr b/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
index 1660db1aa83..de2485b7be0 100644
--- a/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
+++ b/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | fn foo(d: impl Debug + 'static) {
    |                      +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/suggestions/suggest-mut-method-for-loop-closure.stderr b/tests/ui/suggestions/suggest-mut-method-for-loop-closure.stderr
index 8a2df8d7cc1..0bd286e0a62 100644
--- a/tests/ui/suggestions/suggest-mut-method-for-loop-closure.stderr
+++ b/tests/ui/suggestions/suggest-mut-method-for-loop-closure.stderr
@@ -10,6 +10,6 @@ LL |         for mut t in buzz.values() {
 LL |             t.v += 1;
    |             ^^^^^^^^ `t` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/suggestions/suggest-mut-method-for-loop-hashmap.stderr b/tests/ui/suggestions/suggest-mut-method-for-loop-hashmap.stderr
index c442ed6377a..1be14aa8f55 100644
--- a/tests/ui/suggestions/suggest-mut-method-for-loop-hashmap.stderr
+++ b/tests/ui/suggestions/suggest-mut-method-for-loop-hashmap.stderr
@@ -10,6 +10,6 @@ LL |     for (_k, v) in map.iter() {
 LL |         v.v += 1;
    |         ^^^^^^^^ `v` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/suggestions/suggest-mut-method-for-loop.stderr b/tests/ui/suggestions/suggest-mut-method-for-loop.stderr
index 3eb9e1031d7..37bb25b300f 100644
--- a/tests/ui/suggestions/suggest-mut-method-for-loop.stderr
+++ b/tests/ui/suggestions/suggest-mut-method-for-loop.stderr
@@ -10,6 +10,6 @@ LL |     for mut t in buzz.values() {
 LL |         t.v += 1;
    |         ^^^^^^^^ `t` is a `&` reference, so the data it refers to cannot be written
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/suggestions/suggest-pin-macro.stderr b/tests/ui/suggestions/suggest-pin-macro.stderr
index 1220cf650cc..a761a454ad5 100644
--- a/tests/ui/suggestions/suggest-pin-macro.stderr
+++ b/tests/ui/suggestions/suggest-pin-macro.stderr
@@ -14,6 +14,6 @@ LL | struct Test {
 note: required by a bound in `Pin::<&'a mut T>::get_mut`
   --> $SRC_DIR/core/src/pin.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/suggest-remove-refs-1.stderr b/tests/ui/suggestions/suggest-remove-refs-1.stderr
index 387770535f6..523f78dffcc 100644
--- a/tests/ui/suggestions/suggest-remove-refs-1.stderr
+++ b/tests/ui/suggestions/suggest-remove-refs-1.stderr
@@ -12,6 +12,6 @@ LL -     for (i, _) in &v.iter().enumerate() {
 LL +     for (i, _) in v.iter().enumerate() {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/suggest-remove-refs-2.stderr b/tests/ui/suggestions/suggest-remove-refs-2.stderr
index 1632b2abb2f..bbe3261e148 100644
--- a/tests/ui/suggestions/suggest-remove-refs-2.stderr
+++ b/tests/ui/suggestions/suggest-remove-refs-2.stderr
@@ -12,6 +12,6 @@ LL -     for (i, _) in & & & & &v.iter().enumerate() {
 LL +     for (i, _) in v.iter().enumerate() {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/suggest-remove-refs-3.stderr b/tests/ui/suggestions/suggest-remove-refs-3.stderr
index 7bf421a7729..a3e142563ff 100644
--- a/tests/ui/suggestions/suggest-remove-refs-3.stderr
+++ b/tests/ui/suggestions/suggest-remove-refs-3.stderr
@@ -16,6 +16,6 @@ LL -     for (i, _) in & & &
 LL +     for (i, _) in v
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/suggest-remove-refs-4.stderr b/tests/ui/suggestions/suggest-remove-refs-4.stderr
index e4ad17e0671..ed9fc2dd256 100644
--- a/tests/ui/suggestions/suggest-remove-refs-4.stderr
+++ b/tests/ui/suggestions/suggest-remove-refs-4.stderr
@@ -12,6 +12,6 @@ LL ~     let foo = [1,2,3].iter();
 LL ~     for _i in foo {}
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/suggest-ret-on-async-w-late.stderr b/tests/ui/suggestions/suggest-ret-on-async-w-late.stderr
index 352f6da3607..0da0241fe82 100644
--- a/tests/ui/suggestions/suggest-ret-on-async-w-late.stderr
+++ b/tests/ui/suggestions/suggest-ret-on-async-w-late.stderr
@@ -6,6 +6,6 @@ LL | async fn ice(_: &i32) {
 LL |     true
    |     ^^^^ expected `()`, found `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/suggest-semicolon-for-fn-in-extern-block.stderr b/tests/ui/suggestions/suggest-semicolon-for-fn-in-extern-block.stderr
index c5df72c4a47..12da91c20b3 100644
--- a/tests/ui/suggestions/suggest-semicolon-for-fn-in-extern-block.stderr
+++ b/tests/ui/suggestions/suggest-semicolon-for-fn-in-extern-block.stderr
@@ -6,5 +6,5 @@ LL |   fn foo()
 LL | }
    | - unexpected token
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/suggest-split-at-mut.stderr b/tests/ui/suggestions/suggest-split-at-mut.stderr
index bb185138383..c42f09e3201 100644
--- a/tests/ui/suggestions/suggest-split-at-mut.stderr
+++ b/tests/ui/suggestions/suggest-split-at-mut.stderr
@@ -11,6 +11,6 @@ LL |     *a = 5;
    = help: consider using `.split_at_mut(position)` or similar method to obtain two mutable non-overlapping sub-slices
    = help: consider using `.swap(index_1, index_2)` to swap elements at the specified indices
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/suggestions/suggest-trait-in-ufcs-in-hrtb.stderr b/tests/ui/suggestions/suggest-trait-in-ufcs-in-hrtb.stderr
index 0d1eed67c55..c0f0c414227 100644
--- a/tests/ui/suggestions/suggest-trait-in-ufcs-in-hrtb.stderr
+++ b/tests/ui/suggestions/suggest-trait-in-ufcs-in-hrtb.stderr
@@ -4,6 +4,6 @@ error[E0223]: ambiguous associated type
 LL | impl<S> Foo for Bar<S> where for<'a> <&'a S>::Item: Foo {}
    |                                      ^^^^^^^^^^^^^ help: use fully-qualified syntax: `<&'a S as IntoIterator>::Item`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/suggestions/suggest_print_over_printf.stderr b/tests/ui/suggestions/suggest_print_over_printf.stderr
index 1214bec16ce..8a79745133c 100644
--- a/tests/ui/suggestions/suggest_print_over_printf.stderr
+++ b/tests/ui/suggestions/suggest_print_over_printf.stderr
@@ -9,6 +9,6 @@ help: you may have meant to use the `print` macro
 LL |     print!("%d", x);
    |     ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/suggestions/type-ascription-and-other-error.stderr b/tests/ui/suggestions/type-ascription-and-other-error.stderr
index eadf634bb14..4efddca4b47 100644
--- a/tests/ui/suggestions/type-ascription-and-other-error.stderr
+++ b/tests/ui/suggestions/type-ascription-and-other-error.stderr
@@ -4,5 +4,5 @@ error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found
 LL |     not rust;
    |         ^^^^ expected one of 8 possible tokens
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/type-ascription-instead-of-let.stderr b/tests/ui/suggestions/type-ascription-instead-of-let.stderr
index 065b1f4d353..939990d7440 100644
--- a/tests/ui/suggestions/type-ascription-instead-of-let.stderr
+++ b/tests/ui/suggestions/type-ascription-instead-of-let.stderr
@@ -9,5 +9,5 @@ help: you might have meant to introduce a new binding
 LL |         let temp: i32 = fun(5i32);
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/type-ascription-instead-of-method.stderr b/tests/ui/suggestions/type-ascription-instead-of-method.stderr
index b3799101cf0..3242b028d5d 100644
--- a/tests/ui/suggestions/type-ascription-instead-of-method.stderr
+++ b/tests/ui/suggestions/type-ascription-instead-of-method.stderr
@@ -6,5 +6,5 @@ LL |     let _ = Box:new("foo".to_string());
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/type-ascription-instead-of-path-2.stderr b/tests/ui/suggestions/type-ascription-instead-of-path-2.stderr
index 43d00591e74..ba0682cda32 100644
--- a/tests/ui/suggestions/type-ascription-instead-of-path-2.stderr
+++ b/tests/ui/suggestions/type-ascription-instead-of-path-2.stderr
@@ -10,5 +10,5 @@ help: maybe write a path separator here
 LL |     let _ = vec![Ok(2)].into_iter().collect::<Result<Vec<_>,_>>()?;
    |                                            ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/type-ascription-instead-of-path.stderr b/tests/ui/suggestions/type-ascription-instead-of-path.stderr
index 849630218da..566b036e53e 100644
--- a/tests/ui/suggestions/type-ascription-instead-of-path.stderr
+++ b/tests/ui/suggestions/type-ascription-instead-of-path.stderr
@@ -6,5 +6,5 @@ LL |     std:io::stdin();
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/type-ascription-instead-of-variant.stderr b/tests/ui/suggestions/type-ascription-instead-of-variant.stderr
index 11d0f5f527e..6fea7f94052 100644
--- a/tests/ui/suggestions/type-ascription-instead-of-variant.stderr
+++ b/tests/ui/suggestions/type-ascription-instead-of-variant.stderr
@@ -6,5 +6,5 @@ LL |     let _ = Option:Some("");
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/undeclared-module-alloc.stderr b/tests/ui/suggestions/undeclared-module-alloc.stderr
index 39169dfa9f7..a439546492b 100644
--- a/tests/ui/suggestions/undeclared-module-alloc.stderr
+++ b/tests/ui/suggestions/undeclared-module-alloc.stderr
@@ -6,6 +6,6 @@ LL | use alloc::rc::Rc;
    |
    = help: add `extern crate alloc` to use the `alloc` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/suggestions/use-placement-resolve.stderr b/tests/ui/suggestions/use-placement-resolve.stderr
index 77724e7e2a4..562e0bc3fbc 100644
--- a/tests/ui/suggestions/use-placement-resolve.stderr
+++ b/tests/ui/suggestions/use-placement-resolve.stderr
@@ -9,6 +9,6 @@ help: consider importing this trait instead
 LL + use std::fmt::Debug;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/suggestions/use-placement-typeck.stderr b/tests/ui/suggestions/use-placement-typeck.stderr
index e900e12b7df..d8f2d58a248 100644
--- a/tests/ui/suggestions/use-placement-typeck.stderr
+++ b/tests/ui/suggestions/use-placement-typeck.stderr
@@ -16,6 +16,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use m::Foo;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/super-at-top-level.stderr b/tests/ui/super-at-top-level.stderr
index 23613df6752..4dce81fbef4 100644
--- a/tests/ui/super-at-top-level.stderr
+++ b/tests/ui/super-at-top-level.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: there are too many leading `super` keywords
 LL | use super::f;
    |     ^^^^^ there are too many leading `super` keywords
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/svh/changing-crates.stderr b/tests/ui/svh/changing-crates.stderr
index caefdfc96f0..130042e34ec 100644
--- a/tests/ui/svh/changing-crates.stderr
+++ b/tests/ui/svh/changing-crates.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-change-lit.stderr b/tests/ui/svh/svh-change-lit.stderr
index 5e890c6aa57..b4d64a78e96 100644
--- a/tests/ui/svh/svh-change-lit.stderr
+++ b/tests/ui/svh/svh-change-lit.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-change-significant-cfg.stderr b/tests/ui/svh/svh-change-significant-cfg.stderr
index dcc250d5216..7cbbcca993d 100644
--- a/tests/ui/svh/svh-change-significant-cfg.stderr
+++ b/tests/ui/svh/svh-change-significant-cfg.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-change-trait-bound.stderr b/tests/ui/svh/svh-change-trait-bound.stderr
index 2035993d218..b06b4a9617b 100644
--- a/tests/ui/svh/svh-change-trait-bound.stderr
+++ b/tests/ui/svh/svh-change-trait-bound.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-change-type-arg.stderr b/tests/ui/svh/svh-change-type-arg.stderr
index eef85aa9546..c3e2b436fe1 100644
--- a/tests/ui/svh/svh-change-type-arg.stderr
+++ b/tests/ui/svh/svh-change-type-arg.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-change-type-ret.stderr b/tests/ui/svh/svh-change-type-ret.stderr
index 247f74e50df..34602405dd1 100644
--- a/tests/ui/svh/svh-change-type-ret.stderr
+++ b/tests/ui/svh/svh-change-type-ret.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-change-type-static.stderr b/tests/ui/svh/svh-change-type-static.stderr
index 78b54f227f0..94c2d9f15c5 100644
--- a/tests/ui/svh/svh-change-type-static.stderr
+++ b/tests/ui/svh/svh-change-type-static.stderr
@@ -9,6 +9,6 @@ LL | extern crate b;
            crate `a`: $PATH_a
            crate `b`: $PATH_b
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/svh/svh-use-trait.stderr b/tests/ui/svh/svh-use-trait.stderr
index d8a81864dca..31c16973b30 100644
--- a/tests/ui/svh/svh-use-trait.stderr
+++ b/tests/ui/svh/svh-use-trait.stderr
@@ -9,6 +9,6 @@ LL | extern crate utb;
            crate `uta`: $PATH_uta
            crate `utb`: $PATH_utb
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0460`.
diff --git a/tests/ui/switched-expectations.stderr b/tests/ui/switched-expectations.stderr
index 6e1bbf701d7..cc576747400 100644
--- a/tests/ui/switched-expectations.stderr
+++ b/tests/ui/switched-expectations.stderr
@@ -6,6 +6,6 @@ LL |     let ref string: String = var;
    |                              |
    |                              expected `String`, found `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/symbol-names/impl2.stderr b/tests/ui/symbol-names/impl2.stderr
index 0c3205e0108..36f080b6083 100644
--- a/tests/ui/symbol-names/impl2.stderr
+++ b/tests/ui/symbol-names/impl2.stderr
@@ -4,5 +4,5 @@ error: def-path(<[u8; 1 + 2] as Foo>::baz)
 LL |     #[rustc_def_path]
    |     ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/sync/mutexguard-sync.stderr b/tests/ui/sync/mutexguard-sync.stderr
index 4dc5571196c..1501a793d5e 100644
--- a/tests/ui/sync/mutexguard-sync.stderr
+++ b/tests/ui/sync/mutexguard-sync.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `test_sync`
 LL | fn test_sync<T: Sync>(_t: T) {}
    |                 ^^^^ required by this bound in `test_sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/sync/suggest-once-cell.stderr b/tests/ui/sync/suggest-once-cell.stderr
index 20242f4b61c..8a9446a09b9 100644
--- a/tests/ui/sync/suggest-once-cell.stderr
+++ b/tests/ui/sync/suggest-once-cell.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `require_sync`
 LL | fn require_sync<T: Sync>() {}
    |                    ^^^^ required by this bound in `require_sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/sync/suggest-ref-cell.stderr b/tests/ui/sync/suggest-ref-cell.stderr
index ca3ae77b1a0..9ef8ddc18cd 100644
--- a/tests/ui/sync/suggest-ref-cell.stderr
+++ b/tests/ui/sync/suggest-ref-cell.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `require_sync`
 LL | fn require_sync<T: Sync>() {}
    |                    ^^^^ required by this bound in `require_sync`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/tag-type-args.stderr b/tests/ui/tag-type-args.stderr
index 5b54880a685..49ecf65b7e6 100644
--- a/tests/ui/tag-type-args.stderr
+++ b/tests/ui/tag-type-args.stderr
@@ -14,6 +14,6 @@ help: add missing generic argument
 LL | fn foo(c: Quux<T>) { assert!((false)); }
    |               +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/tag-variant-cast-non-nullary.stderr b/tests/ui/tag-variant-cast-non-nullary.stderr
index ae2f5a7aead..560dd7e8164 100644
--- a/tests/ui/tag-variant-cast-non-nullary.stderr
+++ b/tests/ui/tag-variant-cast-non-nullary.stderr
@@ -6,6 +6,6 @@ LL |     let val = v as isize;
    |
    = note: an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/tail-typeck.stderr b/tests/ui/tail-typeck.stderr
index 10dfd2de744..0e470a7b405 100644
--- a/tests/ui/tail-typeck.stderr
+++ b/tests/ui/tail-typeck.stderr
@@ -11,6 +11,6 @@ help: you can convert a `usize` to an `isize` and panic if the converted value d
 LL | fn f() -> isize { return g().try_into().unwrap(); }
    |                             ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/target-feature/gate.stderr b/tests/ui/target-feature/gate.stderr
index 0ec7427c3c4..b3bd12600f8 100644
--- a/tests/ui/target-feature/gate.stderr
+++ b/tests/ui/target-feature/gate.stderr
@@ -7,6 +7,6 @@ LL | #[target_feature(enable = "avx512bw")]
    = note: see issue #44839 <https://github.com/rust-lang/rust/issues/44839> for more information
    = help: add `#![feature(avx512_target_feature)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/target-feature/tied-features-cli.one.stderr b/tests/ui/target-feature/tied-features-cli.one.stderr
index b4b50d98192..bf211fbee2f 100644
--- a/tests/ui/target-feature/tied-features-cli.one.stderr
+++ b/tests/ui/target-feature/tied-features-cli.one.stderr
@@ -1,4 +1,4 @@
 error: the target features paca, pacg must all be either enabled or disabled together
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/target-feature/tied-features-cli.three.stderr b/tests/ui/target-feature/tied-features-cli.three.stderr
index b4b50d98192..bf211fbee2f 100644
--- a/tests/ui/target-feature/tied-features-cli.three.stderr
+++ b/tests/ui/target-feature/tied-features-cli.three.stderr
@@ -1,4 +1,4 @@
 error: the target features paca, pacg must all be either enabled or disabled together
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/target-feature/tied-features-cli.two.stderr b/tests/ui/target-feature/tied-features-cli.two.stderr
index b4b50d98192..bf211fbee2f 100644
--- a/tests/ui/target-feature/tied-features-cli.two.stderr
+++ b/tests/ui/target-feature/tied-features-cli.two.stderr
@@ -1,4 +1,4 @@
 error: the target features paca, pacg must all be either enabled or disabled together
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/test-attrs/custom-test-frameworks/issue-107454.stderr b/tests/ui/test-attrs/custom-test-frameworks/issue-107454.stderr
index bd604afb79f..6ac79924d80 100644
--- a/tests/ui/test-attrs/custom-test-frameworks/issue-107454.stderr
+++ b/tests/ui/test-attrs/custom-test-frameworks/issue-107454.stderr
@@ -11,5 +11,5 @@ LL | #![deny(unnameable_test_items)]
    |         ^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the attribute macro `test_case` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/test-attrs/issue-109816.stderr b/tests/ui/test-attrs/issue-109816.stderr
index e6993287555..6f5e3ae6b63 100644
--- a/tests/ui/test-attrs/issue-109816.stderr
+++ b/tests/ui/test-attrs/issue-109816.stderr
@@ -12,5 +12,5 @@ help: replace with conditional compilation to make the item only exist when test
 LL |     #[cfg(test)]
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/test-attrs/issue-12997-2.stderr b/tests/ui/test-attrs/issue-12997-2.stderr
index 2a3d0e3457b..bc84ff413df 100644
--- a/tests/ui/test-attrs/issue-12997-2.stderr
+++ b/tests/ui/test-attrs/issue-12997-2.stderr
@@ -16,6 +16,6 @@ LL | fn bar(x: isize) { }
    |    ^^^ --------
    = note: this error originates in the attribute macro `bench` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/test-attrs/test-panic-abort-disabled.stderr b/tests/ui/test-attrs/test-panic-abort-disabled.stderr
index 9c65c7360c1..c6aeb41f5ac 100644
--- a/tests/ui/test-attrs/test-panic-abort-disabled.stderr
+++ b/tests/ui/test-attrs/test-panic-abort-disabled.stderr
@@ -1,4 +1,4 @@
 error: building tests with panic=abort is not supported without `-Zpanic_abort_tests`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/test-attrs/test-warns-dead-code.stderr b/tests/ui/test-attrs/test-warns-dead-code.stderr
index 6c0f2884128..1c58e3885a0 100644
--- a/tests/ui/test-attrs/test-warns-dead-code.stderr
+++ b/tests/ui/test-attrs/test-warns-dead-code.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/thread-local/thread-local-mutation.stderr b/tests/ui/thread-local/thread-local-mutation.stderr
index e5dc0e72edf..9001de34adf 100644
--- a/tests/ui/thread-local/thread-local-mutation.stderr
+++ b/tests/ui/thread-local/thread-local-mutation.stderr
@@ -4,6 +4,6 @@ error[E0594]: cannot assign to immutable static item `S`
 LL |     S = "after";
    |     ^^^^^^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/tool-attributes/diagnostic_item.stderr b/tests/ui/tool-attributes/diagnostic_item.stderr
index 743e4b658c6..a181aee6b58 100644
--- a/tests/ui/tool-attributes/diagnostic_item.stderr
+++ b/tests/ui/tool-attributes/diagnostic_item.stderr
@@ -6,6 +6,6 @@ LL | #[rustc_diagnostic_item = "foomp"]
    |
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/tool-attributes/tool-attributes-shadowing.stderr b/tests/ui/tool-attributes/tool-attributes-shadowing.stderr
index 98ad109a07e..f2da6172722 100644
--- a/tests/ui/tool-attributes/tool-attributes-shadowing.stderr
+++ b/tests/ui/tool-attributes/tool-attributes-shadowing.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: could not find `skip` in `rustfmt`
 LL | #[rustfmt::skip]
    |            ^^^^ could not find `skip` in `rustfmt`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/tool_lints-fail.stderr b/tests/ui/tool_lints-fail.stderr
index 16f678144a3..7d80e0728f7 100644
--- a/tests/ui/tool_lints-fail.stderr
+++ b/tests/ui/tool_lints-fail.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unknown_lints)]
    |         ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/track-diagnostics/track2.stderr b/tests/ui/track-diagnostics/track2.stderr
index fe13e5ef3f5..dffa0b0c91c 100644
--- a/tests/ui/track-diagnostics/track2.stderr
+++ b/tests/ui/track-diagnostics/track2.stderr
@@ -13,6 +13,6 @@ help: borrow this binding in the pattern to avoid moving the value
 LL |     let ref _moved @ ref _from = String::from("foo");
    |         +++          +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/track-diagnostics/track4.stderr b/tests/ui/track-diagnostics/track4.stderr
index 9ebf222ee34..d9eaea93638 100644
--- a/tests/ui/track-diagnostics/track4.stderr
+++ b/tests/ui/track-diagnostics/track4.stderr
@@ -10,5 +10,5 @@ help: add `struct` here to parse `onion` as a public struct
 LL | pub struct onion {
    |     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/track-diagnostics/track5.stderr b/tests/ui/track-diagnostics/track5.stderr
index aa54f92b6c0..ecc7d81b3c3 100644
--- a/tests/ui/track-diagnostics/track5.stderr
+++ b/tests/ui/track-diagnostics/track5.stderr
@@ -5,5 +5,5 @@ LL | }
    | ^ unexpected closing delimiter
 -Ztrack-diagnostics: created at compiler/rustc_parse/src/lexer/tokentrees.rs:LL:CC
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/track-diagnostics/track6.stderr b/tests/ui/track-diagnostics/track6.stderr
index 583b02555b4..8ca56d6db21 100644
--- a/tests/ui/track-diagnostics/track6.stderr
+++ b/tests/ui/track-diagnostics/track6.stderr
@@ -8,6 +8,6 @@ LL |     default fn bar() {}
    = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
    = help: add `#![feature(specialization)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr b/tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr
index 32f6b00b20c..9a3bcaa0c4a 100644
--- a/tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr
+++ b/tests/ui/trait-bounds/enum-unit-variant-trait-bound.stderr
@@ -8,6 +8,6 @@ LL |     let _ = Option::<[u8]>::None;
 note: required by a bound in `None`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/trait-bounds/impl-derived-implicit-sized-bound-2.stderr b/tests/ui/trait-bounds/impl-derived-implicit-sized-bound-2.stderr
index 543ceac8e91..84c2ab68da9 100644
--- a/tests/ui/trait-bounds/impl-derived-implicit-sized-bound-2.stderr
+++ b/tests/ui/trait-bounds/impl-derived-implicit-sized-bound-2.stderr
@@ -26,6 +26,6 @@ help: consider restricting the type parameter to satisfy the trait bound
 LL | struct Victim<'a, T: Perpetrator + ?Sized> where Self: Sized {
    |                                            +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/trait-bounds/impl-derived-implicit-sized-bound.stderr b/tests/ui/trait-bounds/impl-derived-implicit-sized-bound.stderr
index f08d685836e..c597ad0b572 100644
--- a/tests/ui/trait-bounds/impl-derived-implicit-sized-bound.stderr
+++ b/tests/ui/trait-bounds/impl-derived-implicit-sized-bound.stderr
@@ -26,6 +26,6 @@ help: consider restricting the type parameter to satisfy the trait bound
 LL |   Self: Sized, Self: Sized
    |              +++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/trait-bounds/issue-82038.stderr b/tests/ui/trait-bounds/issue-82038.stderr
index 30bb4a0a850..a97daece3b3 100644
--- a/tests/ui/trait-bounds/issue-82038.stderr
+++ b/tests/ui/trait-bounds/issue-82038.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | trait Foo {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
index 61132efc414..5024ad21892 100644
--- a/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
+++ b/tests/ui/trait-bounds/restrict-assoc-type-of-generic-bound.stderr
@@ -15,6 +15,6 @@ help: consider further restricting this bound
 LL | pub fn foo<A: MyTrait<T = B>, B>(a: A) -> B {
    |                      +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/trait-bounds/shadowed-path-in-trait-bound-suggestion.stderr b/tests/ui/trait-bounds/shadowed-path-in-trait-bound-suggestion.stderr
index 4547e1c984c..e2a72697501 100644
--- a/tests/ui/trait-bounds/shadowed-path-in-trait-bound-suggestion.stderr
+++ b/tests/ui/trait-bounds/shadowed-path-in-trait-bound-suggestion.stderr
@@ -14,6 +14,6 @@ LL -     pub struct A<H: A::Trait>(pub H);
 LL +     pub struct A<H: Trait>(pub H);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/trait-impl-bound-suggestions.stderr b/tests/ui/trait-impl-bound-suggestions.stderr
index 38679679cf9..c1f31e2b32e 100644
--- a/tests/ui/trait-impl-bound-suggestions.stderr
+++ b/tests/ui/trait-impl-bound-suggestions.stderr
@@ -14,6 +14,6 @@ help: consider further restricting type parameter `X`
 LL | trait InsufficientlyConstrainedGeneric<X=()> where X: std::marker::Copy {
    |                                              ++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/trait-method-number-parameters.stderr b/tests/ui/trait-method-number-parameters.stderr
index e47fe1a8026..cf9b4f2ae79 100644
--- a/tests/ui/trait-method-number-parameters.stderr
+++ b/tests/ui/trait-method-number-parameters.stderr
@@ -8,6 +8,6 @@ LL | /         &mut self,
 LL | |         x: i32,
    | |______________^ expected 3 parameters, found 2
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0050`.
diff --git a/tests/ui/traits/alias/ambiguous.stderr b/tests/ui/traits/alias/ambiguous.stderr
index 203bdc526f6..034e8a3fb7b 100644
--- a/tests/ui/traits/alias/ambiguous.stderr
+++ b/tests/ui/traits/alias/ambiguous.stderr
@@ -23,6 +23,6 @@ help: disambiguate the method for candidate #2
 LL |     B::foo(&t);
    |     ~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0034`.
diff --git a/tests/ui/traits/alias/dont-elaborate-non-self.stderr b/tests/ui/traits/alias/dont-elaborate-non-self.stderr
index 247a4f81280..4e2edb474c0 100644
--- a/tests/ui/traits/alias/dont-elaborate-non-self.stderr
+++ b/tests/ui/traits/alias/dont-elaborate-non-self.stderr
@@ -15,6 +15,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn f<Fut>(a: &dyn F<Fut>) {}
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/alias/impl.stderr b/tests/ui/traits/alias/impl.stderr
index cedcd10213d..ff463f47937 100644
--- a/tests/ui/traits/alias/impl.stderr
+++ b/tests/ui/traits/alias/impl.stderr
@@ -4,6 +4,6 @@ error[E0404]: expected trait, found trait alias `DefaultAlias`
 LL | impl DefaultAlias for () {}
    |      ^^^^^^^^^^^^ not a trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/traits/alias/issue-108072-unmet-trait-alias-bound.stderr b/tests/ui/traits/alias/issue-108072-unmet-trait-alias-bound.stderr
index 39f974f962c..968ad2667a2 100644
--- a/tests/ui/traits/alias/issue-108072-unmet-trait-alias-bound.stderr
+++ b/tests/ui/traits/alias/issue-108072-unmet-trait-alias-bound.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `f`
 LL | fn f(_: impl IteratorAlias) {}
    |              ^^^^^^^^^^^^^ required by this bound in `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr b/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr
index f1b259d5a65..74526b4dbc1 100644
--- a/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr
+++ b/tests/ui/traits/alias/issue-108132-unmet-trait-alias-bound-on-generic-impl.stderr
@@ -20,6 +20,6 @@ LL | impl<I: IteratorAlias> Foo<I> {
    |         |
    |         unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/traits/alias/issue-83613.stderr b/tests/ui/traits/alias/issue-83613.stderr
index a78294da6c1..847fda41776 100644
--- a/tests/ui/traits/alias/issue-83613.stderr
+++ b/tests/ui/traits/alias/issue-83613.stderr
@@ -6,6 +6,6 @@ LL | impl<T: Send> AnotherTrait for T {}
 LL | impl AnotherTrait for OpaqueType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `OpaqueType`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/alias/self-in-const-generics.stderr b/tests/ui/traits/alias/self-in-const-generics.stderr
index 61cc217cfbc..3de31b64c8b 100644
--- a/tests/ui/traits/alias/self-in-const-generics.stderr
+++ b/tests/ui/traits/alias/self-in-const-generics.stderr
@@ -6,6 +6,6 @@ LL | fn foo(x: &dyn BB) {}
    |
    = note: it cannot use `Self` as a type parameter in a supertrait or `where`-clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/alias/self-in-generics.stderr b/tests/ui/traits/alias/self-in-generics.stderr
index 80af4e5aae3..ffc0a00ad7d 100644
--- a/tests/ui/traits/alias/self-in-generics.stderr
+++ b/tests/ui/traits/alias/self-in-generics.stderr
@@ -6,6 +6,6 @@ LL | pub fn f(_f: &dyn SelfInput) {}
    |
    = note: it cannot use `Self` as a type parameter in a supertrait or `where`-clause
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/alias/suggest-trait-alias-instead-of-type.stderr b/tests/ui/traits/alias/suggest-trait-alias-instead-of-type.stderr
index 6e03eeada49..afe34a125b2 100644
--- a/tests/ui/traits/alias/suggest-trait-alias-instead-of-type.stderr
+++ b/tests/ui/traits/alias/suggest-trait-alias-instead-of-type.stderr
@@ -9,6 +9,6 @@ help: you might have meant to use `#![feature(trait_alias)]` instead of a `type`
 LL | trait Strings = Iterator<Item=String>;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/traits/alias/wf.stderr b/tests/ui/traits/alias/wf.stderr
index 7172008d3ee..3be6e8a49d6 100644
--- a/tests/ui/traits/alias/wf.stderr
+++ b/tests/ui/traits/alias/wf.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | trait B<T: Foo> = A<T>;
    |          +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/as-struct-constructor.stderr b/tests/ui/traits/as-struct-constructor.stderr
index d06e85f3a20..42353d210b4 100644
--- a/tests/ui/traits/as-struct-constructor.stderr
+++ b/tests/ui/traits/as-struct-constructor.stderr
@@ -4,6 +4,6 @@ error[E0574]: expected struct, variant or union type, found trait `TraitNotAStru
 LL |     TraitNotAStruct{ value: 0 };
    |     ^^^^^^^^^^^^^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/traits/assoc-type-in-superbad.stderr b/tests/ui/traits/assoc-type-in-superbad.stderr
index 7fa1d2c2eed..2f07a32aa22 100644
--- a/tests/ui/traits/assoc-type-in-superbad.stderr
+++ b/tests/ui/traits/assoc-type-in-superbad.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Foo`
 LL | pub trait Foo: Iterator<Item = <Self as Foo>::Key> {
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-1.stderr b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-1.stderr
index fa7a8a2a093..e7e55d0beee 100644
--- a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-1.stderr
+++ b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-1.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `f`
 LL | fn f<T: X + ?Sized>() {
    |         ^ required by this bound in `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-2.stderr b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-2.stderr
index 68b9319d65c..b7a7784755e 100644
--- a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-2.stderr
+++ b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-2.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `f`
 LL | fn f<T: for<'r> X<'r> + ?Sized>() {
    |         ^^^^^^^^^^^^^ required by this bound in `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-3.stderr b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-3.stderr
index c7af71a4214..77072656c33 100644
--- a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-3.stderr
+++ b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-3.stderr
@@ -12,6 +12,6 @@ LL |
 LL |     }
    |     - `s` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-4.stderr b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-4.stderr
index 4891ee9c29f..5cc38e4371d 100644
--- a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-4.stderr
+++ b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-4.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `f`
 LL | fn f<T: X + ?Sized>() {
    |         ^ required by this bound in `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-5.stderr b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-5.stderr
index 00fdb375346..3e9e6dcac91 100644
--- a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-5.stderr
+++ b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-5.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `is_obj`
 LL | fn is_obj<T: ?Sized + Obj>(_: &T) {}
    |                       ^^^ required by this bound in `is_obj`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-6.stderr b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-6.stderr
index 9b0975e5ed3..0e2a32735e9 100644
--- a/tests/ui/traits/associated_type_bound/check-trait-object-bounds-6.stderr
+++ b/tests/ui/traits/associated_type_bound/check-trait-object-bounds-6.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `is_obj`
 LL | fn is_obj<T: ?Sized + Obj>(_: &T) {}
    |                       ^^^ required by this bound in `is_obj`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/bad-method-typaram-kind.stderr b/tests/ui/traits/bad-method-typaram-kind.stderr
index 4c2d8e9f050..376a83e58a7 100644
--- a/tests/ui/traits/bad-method-typaram-kind.stderr
+++ b/tests/ui/traits/bad-method-typaram-kind.stderr
@@ -16,6 +16,6 @@ help: consider further restricting this bound
 LL | fn foo<T:'static + std::marker::Send>() {
    |                  +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr b/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
index f30fe12b216..c8631ed3677 100644
--- a/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
+++ b/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
@@ -15,6 +15,6 @@ LL |     s.strip_suffix(b'\n').unwrap_or(s)
              &'b str
    = note: required for `u8` to implement `Pattern<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/bound/not-on-bare-trait.stderr b/tests/ui/traits/bound/not-on-bare-trait.stderr
index 36b08a7d309..1d97bf3d8f9 100644
--- a/tests/ui/traits/bound/not-on-bare-trait.stderr
+++ b/tests/ui/traits/bound/not-on-bare-trait.stderr
@@ -29,6 +29,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn foo(_x: &Foo + Send) {
    |            +
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/bound/on-structs-and-enums-in-impls.stderr b/tests/ui/traits/bound/on-structs-and-enums-in-impls.stderr
index 372bbabbd86..48c3688a044 100644
--- a/tests/ui/traits/bound/on-structs-and-enums-in-impls.stderr
+++ b/tests/ui/traits/bound/on-structs-and-enums-in-impls.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Foo`
 LL | struct Foo<T:Trait> {
    |              ^^^^^ required by this bound in `Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/bound/sugar.stderr b/tests/ui/traits/bound/sugar.stderr
index b67648c7b04..3b3ab1e995c 100644
--- a/tests/ui/traits/bound/sugar.stderr
+++ b/tests/ui/traits/bound/sugar.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn a(_x: Box<dyn Foo + Send>) {
    |    ^ -----------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/cache-reached-depth-ice.stderr b/tests/ui/traits/cache-reached-depth-ice.stderr
index 7cd75819277..e84ebc91ae1 100644
--- a/tests/ui/traits/cache-reached-depth-ice.stderr
+++ b/tests/ui/traits/cache-reached-depth-ice.stderr
@@ -7,5 +7,5 @@ LL | fn test<X: ?Sized + Send>() {}
 LL |     test::<A>();
    |     ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/coercion-generic-bad.stderr b/tests/ui/traits/coercion-generic-bad.stderr
index 30a3c40db95..26136c6f72c 100644
--- a/tests/ui/traits/coercion-generic-bad.stderr
+++ b/tests/ui/traits/coercion-generic-bad.stderr
@@ -8,6 +8,6 @@ LL |     let s: Box<dyn Trait<isize>> = Box::new(Struct { person: "Fred" });
    = help: for that trait implementation, expected `&'static str`, found `isize`
    = note: required for the cast from `Box<Struct>` to `Box<dyn Trait<isize>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/coercion-generic-regions.stderr b/tests/ui/traits/coercion-generic-regions.stderr
index ae70202ab7c..576035f8c13 100644
--- a/tests/ui/traits/coercion-generic-regions.stderr
+++ b/tests/ui/traits/coercion-generic-regions.stderr
@@ -12,6 +12,6 @@ LL |     let s: Box<dyn Trait<&'static str>> = Box::new(Struct { person: person
 LL | }
    | - `person` dropped here while still borrowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/traits/copy-guessing.stderr b/tests/ui/traits/copy-guessing.stderr
index 7e676c9da01..750140c017c 100644
--- a/tests/ui/traits/copy-guessing.stderr
+++ b/tests/ui/traits/copy-guessing.stderr
@@ -9,6 +9,6 @@ help: consider giving `n` an explicit type, where the type for type parameter `T
 LL |     let n: Option<T> = None;
    |          +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/traits/copy-impl-cannot-normalize.stderr b/tests/ui/traits/copy-impl-cannot-normalize.stderr
index 86c511c0895..3bdb8b70172 100644
--- a/tests/ui/traits/copy-impl-cannot-normalize.stderr
+++ b/tests/ui/traits/copy-impl-cannot-normalize.stderr
@@ -19,6 +19,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: TraitFoo> Copy for Foo<T> {}
    |       ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
index 13042521184..56544dd4def 100644
--- a/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
+++ b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr
@@ -17,6 +17,6 @@ help: consider restricting type parameter `'any`
 LL | impl<'any: 'static> Copy for Bar<'any> {}
    |          +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/traits/cycle-cache-err-60010.stderr b/tests/ui/traits/cycle-cache-err-60010.stderr
index aee41c43aef..4f9615104cb 100644
--- a/tests/ui/traits/cycle-cache-err-60010.stderr
+++ b/tests/ui/traits/cycle-cache-err-60010.stderr
@@ -37,6 +37,6 @@ LL | where
 LL |     DB: SourceDatabase,
    |         -------------- unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/default-method/rustc_must_implement_one_of.stderr b/tests/ui/traits/default-method/rustc_must_implement_one_of.stderr
index 5a4dd1388b2..7ad10cfce98 100644
--- a/tests/ui/traits/default-method/rustc_must_implement_one_of.stderr
+++ b/tests/ui/traits/default-method/rustc_must_implement_one_of.stderr
@@ -10,6 +10,6 @@ note: required because of this annotation
 LL | #[rustc_must_implement_one_of(eq, neq)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/traits/default-method/rustc_must_implement_one_of_gated.stderr b/tests/ui/traits/default-method/rustc_must_implement_one_of_gated.stderr
index 228bc3e35c2..cb7eb1567c8 100644
--- a/tests/ui/traits/default-method/rustc_must_implement_one_of_gated.stderr
+++ b/tests/ui/traits/default-method/rustc_must_implement_one_of_gated.stderr
@@ -6,6 +6,6 @@ LL | #[rustc_must_implement_one_of(eq, neq)]
    |
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/deny-builtin-object-impl.current.stderr b/tests/ui/traits/deny-builtin-object-impl.current.stderr
index 8ca3d3a057f..0dbf8f0e668 100644
--- a/tests/ui/traits/deny-builtin-object-impl.current.stderr
+++ b/tests/ui/traits/deny-builtin-object-impl.current.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `test_not_object`
 LL | fn test_not_object<T: NotObject + ?Sized>() {}
    |                       ^^^^^^^^^ required by this bound in `test_not_object`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/deny-builtin-object-impl.next.stderr b/tests/ui/traits/deny-builtin-object-impl.next.stderr
index 8ca3d3a057f..0dbf8f0e668 100644
--- a/tests/ui/traits/deny-builtin-object-impl.next.stderr
+++ b/tests/ui/traits/deny-builtin-object-impl.next.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `test_not_object`
 LL | fn test_not_object<T: NotObject + ?Sized>() {}
    |                       ^^^^^^^^^ required by this bound in `test_not_object`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/do-not-mention-type-params-by-name-in-suggestion-issue-96292.stderr b/tests/ui/traits/do-not-mention-type-params-by-name-in-suggestion-issue-96292.stderr
index 2185c51e59d..460595dd961 100644
--- a/tests/ui/traits/do-not-mention-type-params-by-name-in-suggestion-issue-96292.stderr
+++ b/tests/ui/traits/do-not-mention-type-params-by-name-in-suggestion-issue-96292.stderr
@@ -17,6 +17,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     <Thing<bool> as Method<T>>::method(thing, 42);
    |     +++++++++++++++++++++++++++++++++++     ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/duplicate-methods.stderr b/tests/ui/traits/duplicate-methods.stderr
index 6aa88d0dff4..06232772678 100644
--- a/tests/ui/traits/duplicate-methods.stderr
+++ b/tests/ui/traits/duplicate-methods.stderr
@@ -8,6 +8,6 @@ LL |     fn orange(&self);
    |
    = note: `orange` must be defined only once in the value namespace of this trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/ui/traits/ice-with-dyn-pointee-errors.stderr b/tests/ui/traits/ice-with-dyn-pointee-errors.stderr
index 8ad11c3344a..8bfda71bac1 100644
--- a/tests/ui/traits/ice-with-dyn-pointee-errors.stderr
+++ b/tests/ui/traits/ice-with-dyn-pointee-errors.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `unknown_sized_object_ptr_in`
 LL | fn unknown_sized_object_ptr_in(_: &(impl Pointee<Metadata = ()> + ?Sized)) {}
    |                                                  ^^^^^^^^^^^^^ required by this bound in `unknown_sized_object_ptr_in`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/ignore-err-impls.stderr b/tests/ui/traits/ignore-err-impls.stderr
index 45bd533b5c6..955e2d78049 100644
--- a/tests/ui/traits/ignore-err-impls.stderr
+++ b/tests/ui/traits/ignore-err-impls.stderr
@@ -9,6 +9,6 @@ help: you might be missing a type parameter
 LL | impl<Type> Generic<Type> for S {}
    |     ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/traits/impl-1.stderr b/tests/ui/traits/impl-1.stderr
index 7694e3f5cfa..8c290addc7b 100644
--- a/tests/ui/traits/impl-1.stderr
+++ b/tests/ui/traits/impl-1.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `foo` found for reference `&i32` in the current sc
 LL |     x.foo();
    |       ^^^ method not found in `&i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/traits/impl-bounds-checking.stderr b/tests/ui/traits/impl-bounds-checking.stderr
index bfa8213abe7..61302bfa088 100644
--- a/tests/ui/traits/impl-bounds-checking.stderr
+++ b/tests/ui/traits/impl-bounds-checking.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Getter`
 LL | trait Getter<T: Clone2> {
    |                 ^^^^^^ required by this bound in `Getter`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/impl-different-num-params.stderr b/tests/ui/traits/impl-different-num-params.stderr
index 910ba351064..0f73f5ca7de 100644
--- a/tests/ui/traits/impl-different-num-params.stderr
+++ b/tests/ui/traits/impl-different-num-params.stderr
@@ -7,6 +7,6 @@ LL |     fn bar(&self, x: usize) -> Self;
 LL |     fn bar(&self) -> isize {
    |            ^^^^^ expected 2 parameters, found 1
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0050`.
diff --git a/tests/ui/traits/impl-for-module.stderr b/tests/ui/traits/impl-for-module.stderr
index 6ec4083b513..b715c699e89 100644
--- a/tests/ui/traits/impl-for-module.stderr
+++ b/tests/ui/traits/impl-for-module.stderr
@@ -7,6 +7,6 @@ LL | trait A {
 LL | impl A for a {
    |            ^ help: a trait with a similar name exists: `A`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0573`.
diff --git a/tests/ui/traits/impl-method-mismatch.stderr b/tests/ui/traits/impl-method-mismatch.stderr
index 252b5aff96a..2655d465f23 100644
--- a/tests/ui/traits/impl-method-mismatch.stderr
+++ b/tests/ui/traits/impl-method-mismatch.stderr
@@ -12,6 +12,6 @@ LL |     fn jumbo(&self, x: &usize) -> usize;
    = note: expected signature `fn(&usize, &usize) -> usize`
               found signature `unsafe fn(&usize, &usize)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/traits/impl-of-supertrait-has-wrong-lifetime-parameters.stderr b/tests/ui/traits/impl-of-supertrait-has-wrong-lifetime-parameters.stderr
index 1bace8ab286..092776edea7 100644
--- a/tests/ui/traits/impl-of-supertrait-has-wrong-lifetime-parameters.stderr
+++ b/tests/ui/traits/impl-of-supertrait-has-wrong-lifetime-parameters.stderr
@@ -22,6 +22,6 @@ LL | impl<'a,'b> T2<'a, 'b> for S<'a, 'b> {
    = note: expected `T1<'a>`
               found `T1<'_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0495`.
diff --git a/tests/ui/traits/inductive-overflow/lifetime.stderr b/tests/ui/traits/inductive-overflow/lifetime.stderr
index 7ab2864a8cf..b34bb0361f1 100644
--- a/tests/ui/traits/inductive-overflow/lifetime.stderr
+++ b/tests/ui/traits/inductive-overflow/lifetime.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `is_send`
 LL | fn is_send<S: NotAuto>() {}
    |               ^^^^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/inductive-overflow/simultaneous.stderr b/tests/ui/traits/inductive-overflow/simultaneous.stderr
index e3b4ec07d23..b9a746e44ba 100644
--- a/tests/ui/traits/inductive-overflow/simultaneous.stderr
+++ b/tests/ui/traits/inductive-overflow/simultaneous.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `is_ee`
 LL | fn is_ee<T: Combo>(t: T) {
    |             ^^^^^ required by this bound in `is_ee`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/inductive-overflow/supertrait.stderr b/tests/ui/traits/inductive-overflow/supertrait.stderr
index b537ecf1721..f2dccbbbb2c 100644
--- a/tests/ui/traits/inductive-overflow/supertrait.stderr
+++ b/tests/ui/traits/inductive-overflow/supertrait.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `copy`
 LL | fn copy<T: Magic>(x: T) -> (T, T) { (x, x) }
    |            ^^^^^ required by this bound in `copy`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/invalid_operator_trait.stderr b/tests/ui/traits/invalid_operator_trait.stderr
index 8c6e3695905..f2e5e9080b1 100644
--- a/tests/ui/traits/invalid_operator_trait.stderr
+++ b/tests/ui/traits/invalid_operator_trait.stderr
@@ -4,5 +4,5 @@ error: `add` must not have any generic parameters
 LL |     fn add<Y>(self, _: RHS) -> Self::Output;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/issue-18400.stderr b/tests/ui/traits/issue-18400.stderr
index edaf08f490f..146ba16397a 100644
--- a/tests/ui/traits/issue-18400.stderr
+++ b/tests/ui/traits/issue-18400.stderr
@@ -15,6 +15,6 @@ LL | impl<'a, T, S> Set<&'a [T]> for S where
    = note: 128 redundant requirements hidden
    = note: required for `{integer}` to implement `Set<&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[&[_]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/issue-22384.stderr b/tests/ui/traits/issue-22384.stderr
index 1f767a443d0..f53c95c2b67 100644
--- a/tests/ui/traits/issue-22384.stderr
+++ b/tests/ui/traits/issue-22384.stderr
@@ -4,6 +4,6 @@ error[E0576]: cannot find associated type `foobar` in trait `Copy`
 LL |     <<i32 as Copy>::foobar as Trait>::foo();
    |                     ^^^^^^ not found in `Copy`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0576`.
diff --git a/tests/ui/traits/issue-28576.stderr b/tests/ui/traits/issue-28576.stderr
index 203cd0630eb..9fe50864642 100644
--- a/tests/ui/traits/issue-28576.stderr
+++ b/tests/ui/traits/issue-28576.stderr
@@ -15,6 +15,6 @@ LL | pub trait Bar: Foo<Assoc=()> {
    |           |    ...because it uses `Self` as a type parameter
    |           this trait cannot be made into an object...
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/issue-43784-supertrait.stderr b/tests/ui/traits/issue-43784-supertrait.stderr
index 6b5b721384c..2bf365745a6 100644
--- a/tests/ui/traits/issue-43784-supertrait.stderr
+++ b/tests/ui/traits/issue-43784-supertrait.stderr
@@ -19,6 +19,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::marker::Copy> Complete for T {}
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/issue-52893.stderr b/tests/ui/traits/issue-52893.stderr
index c57921a08aa..c37dde90e33 100644
--- a/tests/ui/traits/issue-52893.stderr
+++ b/tests/ui/traits/issue-52893.stderr
@@ -24,6 +24,6 @@ note: method defined here
 LL |     fn push(self, other: T) -> Self::PushRes;
    |        ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/issue-65284-suggest-generic-trait-bound.stderr b/tests/ui/traits/issue-65284-suggest-generic-trait-bound.stderr
index ae33e61d83b..22b5af43ba9 100644
--- a/tests/ui/traits/issue-65284-suggest-generic-trait-bound.stderr
+++ b/tests/ui/traits/issue-65284-suggest-generic-trait-bound.stderr
@@ -12,6 +12,6 @@ help: the following trait defines an item `foo`, perhaps you need to restrict ty
 LL | fn do_stuff<T : Bar + Foo>(t : T) {
    |                     +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/traits/issue-65673.stderr b/tests/ui/traits/issue-65673.stderr
index 8f01d7c53e7..3c327f9edd5 100644
--- a/tests/ui/traits/issue-65673.stderr
+++ b/tests/ui/traits/issue-65673.stderr
@@ -7,6 +7,6 @@ LL | trait Alias<T> = where T: Trait;
 LL |     type Ctx = dyn Alias<T>;
    |                ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0224`.
diff --git a/tests/ui/traits/issue-68295.stderr b/tests/ui/traits/issue-68295.stderr
index 671a97666fd..8bc31530241 100644
--- a/tests/ui/traits/issue-68295.stderr
+++ b/tests/ui/traits/issue-68295.stderr
@@ -12,6 +12,6 @@ LL |     input.into_owned()
    = help: consider constraining the associated type `<() as Allocator<R, C>>::Buffer` to `u32`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/issue-7013.stderr b/tests/ui/traits/issue-7013.stderr
index 1c0e8bcf185..17493663172 100644
--- a/tests/ui/traits/issue-7013.stderr
+++ b/tests/ui/traits/issue-7013.stderr
@@ -14,6 +14,6 @@ LL | struct B {
    |        ^
    = note: required for the cast from `Box<B>` to `Box<dyn Foo + Send>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/issue-71036.stderr b/tests/ui/traits/issue-71036.stderr
index 79eb7a2ae8b..2452731f19f 100644
--- a/tests/ui/traits/issue-71036.stderr
+++ b/tests/ui/traits/issue-71036.stderr
@@ -7,6 +7,6 @@ LL | impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Foo<'a, U>> for
    = note: all implementations of `Unsize` are provided automatically by the compiler, see <https://doc.rust-lang.org/stable/std/marker/trait.Unsize.html> for more information
    = note: required for `&'a &'a T` to implement `DispatchFromDyn<&'a &'a U>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/issue-71136.stderr b/tests/ui/traits/issue-71136.stderr
index ef55796187e..2c03c6bf08e 100644
--- a/tests/ui/traits/issue-71136.stderr
+++ b/tests/ui/traits/issue-71136.stderr
@@ -15,6 +15,6 @@ LL + #[derive(Clone)]
 LL | struct Foo(u8);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/issue-72410.stderr b/tests/ui/traits/issue-72410.stderr
index c7beb834b57..58266e1842e 100644
--- a/tests/ui/traits/issue-72410.stderr
+++ b/tests/ui/traits/issue-72410.stderr
@@ -20,6 +20,6 @@ help: alternatively, consider constraining `map` so it does not apply to trait o
 LL |     where for<'a> &'a mut [dyn Bar]:, Self: Sized ;
    |                                     +++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/issue-75627.stderr b/tests/ui/traits/issue-75627.stderr
index 1675edc9ff0..137985ee046 100644
--- a/tests/ui/traits/issue-75627.stderr
+++ b/tests/ui/traits/issue-75627.stderr
@@ -9,6 +9,6 @@ help: you might be missing a type parameter
 LL | unsafe impl<T> Send for Foo<T> {}
    |            +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/traits/issue-79458.stderr b/tests/ui/traits/issue-79458.stderr
index 08f7bbbf0ea..c80efbe9287 100644
--- a/tests/ui/traits/issue-79458.stderr
+++ b/tests/ui/traits/issue-79458.stderr
@@ -11,6 +11,6 @@ LL |     bar: &'a mut T
    = note: `Clone` is implemented for `&T`, but not for `&mut T`
    = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/issue-8153.stderr b/tests/ui/traits/issue-8153.stderr
index ae214bb9e9b..8882097af33 100644
--- a/tests/ui/traits/issue-8153.stderr
+++ b/tests/ui/traits/issue-8153.stderr
@@ -9,6 +9,6 @@ LL |     fn bar(&self) -> isize {1}
 LL |     fn bar(&self) -> isize {2}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definition
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0201`.
diff --git a/tests/ui/traits/issue-85735.stderr b/tests/ui/traits/issue-85735.stderr
index 9e80497ca6e..1aba4183348 100644
--- a/tests/ui/traits/issue-85735.stderr
+++ b/tests/ui/traits/issue-85735.stderr
@@ -13,6 +13,6 @@ LL |
 LL |     T: FnMut(&'b ()),
    |        ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/issue-91594.stderr b/tests/ui/traits/issue-91594.stderr
index 85d903fadd1..13568179e81 100644
--- a/tests/ui/traits/issue-91594.stderr
+++ b/tests/ui/traits/issue-91594.stderr
@@ -13,6 +13,6 @@ LL | impl<M: HasComponent<()>> Component<M> for Foo {
    |         |
    |         unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/issue-91949-hangs-on-recursion.stderr b/tests/ui/traits/issue-91949-hangs-on-recursion.stderr
index 4593fa2c485..c4324f0f0a8 100644
--- a/tests/ui/traits/issue-91949-hangs-on-recursion.stderr
+++ b/tests/ui/traits/issue-91949-hangs-on-recursion.stderr
@@ -25,6 +25,6 @@ LL | impl<T, I: Iterator<Item = T>> Iterator for IteratorOfWrapped<T, I> {
    = note: 256 redundant requirements hidden
    = note: required for `IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), Map<IteratorOfWrapped<(), std::iter::Empty<()>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>, {closure@$DIR/issue-91949-hangs-on-recursion.rs:28:45: 28:48}>>` to implement `Iterator`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/issue-95898.stderr b/tests/ui/traits/issue-95898.stderr
index ca7bacdbf41..0bb0b2840e5 100644
--- a/tests/ui/traits/issue-95898.stderr
+++ b/tests/ui/traits/issue-95898.stderr
@@ -12,6 +12,6 @@ help: the following trait defines an item `clone`, perhaps you need to restrict
 LL | fn foo<T: Clone>(t: T) {
    |           +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/traits/issue-97576.stderr b/tests/ui/traits/issue-97576.stderr
index 9062a0fab63..2c6cfd83b95 100644
--- a/tests/ui/traits/issue-97576.stderr
+++ b/tests/ui/traits/issue-97576.stderr
@@ -6,6 +6,6 @@ LL |             bar: bar.into(),
    |
    = note: required for `impl ToString` to implement `Into<String>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/map-types.stderr b/tests/ui/traits/map-types.stderr
index 4315056f206..b19b5d2e1dd 100644
--- a/tests/ui/traits/map-types.stderr
+++ b/tests/ui/traits/map-types.stderr
@@ -7,6 +7,6 @@ LL |     let y: Box<dyn Map<usize, isize>> = Box::new(x);
    = help: the trait `Map<K, V>` is implemented for `HashMap<K, V>`
    = note: required for the cast from `Box<Box<dyn Map<isize, isize>>>` to `Box<dyn Map<usize, isize>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/method-private.stderr b/tests/ui/traits/method-private.stderr
index e11799308c5..d19f0bc086b 100644
--- a/tests/ui/traits/method-private.stderr
+++ b/tests/ui/traits/method-private.stderr
@@ -13,6 +13,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use inner::Bar;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0624`.
diff --git a/tests/ui/traits/multidispatch-bad.stderr b/tests/ui/traits/multidispatch-bad.stderr
index d58f1e2d9e5..0bb095fb0e1 100644
--- a/tests/ui/traits/multidispatch-bad.stderr
+++ b/tests/ui/traits/multidispatch-bad.stderr
@@ -16,6 +16,6 @@ help: change the type of the numeric literal from `i32` to `u32`
 LL |     test(22i32, 44u32);
    |                   ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/multidispatch-convert-ambig-dest.stderr b/tests/ui/traits/multidispatch-convert-ambig-dest.stderr
index e3bfc78bb08..17c3db9ad33 100644
--- a/tests/ui/traits/multidispatch-convert-ambig-dest.stderr
+++ b/tests/ui/traits/multidispatch-convert-ambig-dest.stderr
@@ -26,6 +26,6 @@ help: consider specifying the generic arguments
 LL |     test::<i32, U>(22, std::default::Default::default());
    |         ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/mutual-recursion-issue-75860.stderr b/tests/ui/traits/mutual-recursion-issue-75860.stderr
index 23e182738f7..420ed2dcd2f 100644
--- a/tests/ui/traits/mutual-recursion-issue-75860.stderr
+++ b/tests/ui/traits/mutual-recursion-issue-75860.stderr
@@ -8,6 +8,6 @@ LL |     iso(left, right)
 note: required by a bound in `Option`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr b/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr
index b253fbd0da7..a232e6d8619 100644
--- a/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr
+++ b/tests/ui/traits/negative-impls/feature-gate-negative_impls.stderr
@@ -7,6 +7,6 @@ LL | impl !MyTrait for u32 {}
    = note: see issue #68318 <https://github.com/rust-lang/rust/issues/68318> for more information
    = help: add `#![feature(negative_impls)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/negative-impls/negative-default-impls.stderr b/tests/ui/traits/negative-impls/negative-default-impls.stderr
index 7b54cf54222..328e744a1e3 100644
--- a/tests/ui/traits/negative-impls/negative-default-impls.stderr
+++ b/tests/ui/traits/negative-impls/negative-default-impls.stderr
@@ -14,6 +14,6 @@ error[E0750]: negative impls cannot be default impls
 LL | default impl !MyTrait for u32 {}
    | ^^^^^^^      ^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0750`.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr b/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr
index 1cfa49b20f3..97727da76f2 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr
+++ b/tests/ui/traits/negative-impls/negative-specializes-positive-item.stderr
@@ -17,6 +17,6 @@ LL | impl<T> MyTrait for T {
 LL | impl !MyTrait for u32 {}
    | ^^^^^^^^^^^^^^^^^^^^^ negative implementation here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/negative-impls/negative-specializes-positive.stderr b/tests/ui/traits/negative-impls/negative-specializes-positive.stderr
index 9f9e28678ab..100f97aba93 100644
--- a/tests/ui/traits/negative-impls/negative-specializes-positive.stderr
+++ b/tests/ui/traits/negative-impls/negative-specializes-positive.stderr
@@ -16,6 +16,6 @@ LL | impl<T> MyTrait for T {}
 LL | impl !MyTrait for u32 {}
    | ^^^^^^^^^^^^^^^^^^^^^ negative implementation here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/negative-impls/no-items.stderr b/tests/ui/traits/negative-impls/no-items.stderr
index 040d9d14503..36436dfba9d 100644
--- a/tests/ui/traits/negative-impls/no-items.stderr
+++ b/tests/ui/traits/negative-impls/no-items.stderr
@@ -4,6 +4,6 @@ error[E0749]: negative impls cannot have any items
 LL |     type Foo = i32;
    |     ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0749`.
diff --git a/tests/ui/traits/negative-impls/pin-unsound-issue-66544-clone.stderr b/tests/ui/traits/negative-impls/pin-unsound-issue-66544-clone.stderr
index a87acb1fb09..4778f31ff3a 100644
--- a/tests/ui/traits/negative-impls/pin-unsound-issue-66544-clone.stderr
+++ b/tests/ui/traits/negative-impls/pin-unsound-issue-66544-clone.stderr
@@ -6,6 +6,6 @@ LL | impl<'a> Clone for &'a mut MyType<'a> {
    |
    = note: negative implementation in crate `core`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/negative-impls/pin-unsound-issue-66544-derefmut.stderr b/tests/ui/traits/negative-impls/pin-unsound-issue-66544-derefmut.stderr
index 9185e8f8430..95d7f6ba912 100644
--- a/tests/ui/traits/negative-impls/pin-unsound-issue-66544-derefmut.stderr
+++ b/tests/ui/traits/negative-impls/pin-unsound-issue-66544-derefmut.stderr
@@ -6,6 +6,6 @@ LL | impl<'a> DerefMut for &'a MyType<'a> {
    |
    = note: negative implementation in crate `core`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/negative-impls/positive-specializes-negative.stderr b/tests/ui/traits/negative-impls/positive-specializes-negative.stderr
index 545f94143ad..1655cb05019 100644
--- a/tests/ui/traits/negative-impls/positive-specializes-negative.stderr
+++ b/tests/ui/traits/negative-impls/positive-specializes-negative.stderr
@@ -16,6 +16,6 @@ LL | impl<T> !MyTrait for T {}
 LL | impl MyTrait for u32 {}
    | ^^^^^^^^^^^^^^^^^^^^ positive implementation here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0751`.
diff --git a/tests/ui/traits/new-solver/alias_eq_substs_eq_not_intercrate.stderr b/tests/ui/traits/new-solver/alias_eq_substs_eq_not_intercrate.stderr
index 46677a58316..8c6840f72a7 100644
--- a/tests/ui/traits/new-solver/alias_eq_substs_eq_not_intercrate.stderr
+++ b/tests/ui/traits/new-solver/alias_eq_substs_eq_not_intercrate.stderr
@@ -8,6 +8,6 @@ LL | impl<U: TraitB> Overlaps<U> for <U as TraitB>::Assoc {}
    |
    = note: downstream crates may implement trait `TraitB` for type `std::boxed::Box<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/new-solver/assembly/runaway-impl-candidate-selection.stderr b/tests/ui/traits/new-solver/assembly/runaway-impl-candidate-selection.stderr
index 414deb47727..4bd55ee80c6 100644
--- a/tests/ui/traits/new-solver/assembly/runaway-impl-candidate-selection.stderr
+++ b/tests/ui/traits/new-solver/assembly/runaway-impl-candidate-selection.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `iter`
 LL | fn iter<T: Iterator>() -> <T as Iterator>::Item {
    |            ^^^^^^^^ required by this bound in `iter`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/new-solver/async.fail.stderr b/tests/ui/traits/new-solver/async.fail.stderr
index 44097b556fc..ebd0ada2604 100644
--- a/tests/ui/traits/new-solver/async.fail.stderr
+++ b/tests/ui/traits/new-solver/async.fail.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `needs_async`
 LL | fn needs_async(_: impl Future<Output = i32>) {}
    |                               ^^^^^^^^^^^^ required by this bound in `needs_async`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/new-solver/auto-with-drop_tracking_mir.fail.stderr b/tests/ui/traits/new-solver/auto-with-drop_tracking_mir.fail.stderr
index 4aefdd6bb07..ac05dfb2d46 100644
--- a/tests/ui/traits/new-solver/auto-with-drop_tracking_mir.fail.stderr
+++ b/tests/ui/traits/new-solver/auto-with-drop_tracking_mir.fail.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `is_send`
 LL |     fn is_send(_: impl Send) {}
    |                        ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/borrowck-error.stderr b/tests/ui/traits/new-solver/borrowck-error.stderr
index a7d8201747a..4cb41e7d597 100644
--- a/tests/ui/traits/new-solver/borrowck-error.stderr
+++ b/tests/ui/traits/new-solver/borrowck-error.stderr
@@ -7,6 +7,6 @@ LL |     &HashMap::new()
    |     |temporary value created here
    |     returns a reference to data owned by the current function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/traits/new-solver/builtin-fn-must-return-sized.stderr b/tests/ui/traits/new-solver/builtin-fn-must-return-sized.stderr
index 4eaa259617b..08047852f20 100644
--- a/tests/ui/traits/new-solver/builtin-fn-must-return-sized.stderr
+++ b/tests/ui/traits/new-solver/builtin-fn-must-return-sized.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `foo`
 LL | fn foo<F: Fn<T>, T: Tuple>(f: Option<F>, t: T) {
    |           ^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/coherence/issue-102048.stderr b/tests/ui/traits/new-solver/coherence/issue-102048.stderr
index 41bf68a1d9f..4e93ae28496 100644
--- a/tests/ui/traits/new-solver/coherence/issue-102048.stderr
+++ b/tests/ui/traits/new-solver/coherence/issue-102048.stderr
@@ -11,6 +11,6 @@ LL | / impl<T, U> Trait<for<'a> fn(<U as WithAssoc1<'a>>::Assoc, u32)> for (T, U
 LL | |     U: for<'a> WithAssoc1<'a>
    | |_____________________________^ conflicting implementation for `(_, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/new-solver/coherence/trait_ref_is_knowable-norm-overflow.stderr b/tests/ui/traits/new-solver/coherence/trait_ref_is_knowable-norm-overflow.stderr
index 5d5f325e4b4..e3c0dabf549 100644
--- a/tests/ui/traits/new-solver/coherence/trait_ref_is_knowable-norm-overflow.stderr
+++ b/tests/ui/traits/new-solver/coherence/trait_ref_is_knowable-norm-overflow.stderr
@@ -7,6 +7,6 @@ LL | struct LocalTy;
 LL | impl Trait for <LocalTy as Overflow>::Assoc {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `<LocalTy as Overflow>::Assoc`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/new-solver/const-param-placeholder.fail.stderr b/tests/ui/traits/new-solver/const-param-placeholder.fail.stderr
index 4db6e22e57f..163710706b0 100644
--- a/tests/ui/traits/new-solver/const-param-placeholder.fail.stderr
+++ b/tests/ui/traits/new-solver/const-param-placeholder.fail.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `needs_foo`
 LL | fn needs_foo<F: Foo>() {}
    |                 ^^^ required by this bound in `needs_foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/cycles/coinduction/fixpoint-exponential-growth.stderr b/tests/ui/traits/new-solver/cycles/coinduction/fixpoint-exponential-growth.stderr
index 1ac0e297729..05aaf6108f1 100644
--- a/tests/ui/traits/new-solver/cycles/coinduction/fixpoint-exponential-growth.stderr
+++ b/tests/ui/traits/new-solver/cycles/coinduction/fixpoint-exponential-growth.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `impls`
 LL | fn impls<T: Trait>() {}
    |             ^^^^^ required by this bound in `impls`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/new-solver/cycles/coinduction/incompleteness-unstable-result.stderr b/tests/ui/traits/new-solver/cycles/coinduction/incompleteness-unstable-result.stderr
index f1871ff0564..d4932191791 100644
--- a/tests/ui/traits/new-solver/cycles/coinduction/incompleteness-unstable-result.stderr
+++ b/tests/ui/traits/new-solver/cycles/coinduction/incompleteness-unstable-result.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `impls_trait`
 LL | fn impls_trait<T: ?Sized + Trait<U, V, D>, U: ?Sized, V: ?Sized, D: ?Sized>() {}
    |                            ^^^^^^^^^^^^^^ required by this bound in `impls_trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/cycles/fixpoint-rerun-all-cycle-heads.stderr b/tests/ui/traits/new-solver/cycles/fixpoint-rerun-all-cycle-heads.stderr
index 4cbd0898148..7b3075f4ff3 100644
--- a/tests/ui/traits/new-solver/cycles/fixpoint-rerun-all-cycle-heads.stderr
+++ b/tests/ui/traits/new-solver/cycles/fixpoint-rerun-all-cycle-heads.stderr
@@ -6,5 +6,5 @@ LL | fn check<'a, T: ?Sized>() {
 LL |     impls_trait::<'a, 'static, A<T>>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/new-solver/cycles/inductive-cycle-but-err.stderr b/tests/ui/traits/new-solver/cycles/inductive-cycle-but-err.stderr
index 57227321a6d..acacaf6a331 100644
--- a/tests/ui/traits/new-solver/cycles/inductive-cycle-but-err.stderr
+++ b/tests/ui/traits/new-solver/cycles/inductive-cycle-but-err.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `impls_trait`
 LL | fn impls_trait<T: Trait>() {}
    |                   ^^^^^ required by this bound in `impls_trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/dont-normalize-proj-with-error.stderr b/tests/ui/traits/new-solver/dont-normalize-proj-with-error.stderr
index 5a7459ec1fd..576ede52aff 100644
--- a/tests/ui/traits/new-solver/dont-normalize-proj-with-error.stderr
+++ b/tests/ui/traits/new-solver/dont-normalize-proj-with-error.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `TypeError` in this scope
 LL | fn type_error() -> TypeError { todo!() }
    |                    ^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/traits/new-solver/dont-type_of-tait-in-defining-scope.not_send.stderr b/tests/ui/traits/new-solver/dont-type_of-tait-in-defining-scope.not_send.stderr
index a31bfd9589b..076dab29d89 100644
--- a/tests/ui/traits/new-solver/dont-type_of-tait-in-defining-scope.not_send.stderr
+++ b/tests/ui/traits/new-solver/dont-type_of-tait-in-defining-scope.not_send.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `needs_send`
 LL | fn needs_send<T: Send>() {}
    |                  ^^^^ required by this bound in `needs_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/new-solver/equating-projection-cyclically.stderr b/tests/ui/traits/new-solver/equating-projection-cyclically.stderr
index 6031d4f08ee..91dd3ebc31b 100644
--- a/tests/ui/traits/new-solver/equating-projection-cyclically.stderr
+++ b/tests/ui/traits/new-solver/equating-projection-cyclically.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     x = transform(x);
    |         ^^^^^^^^^^^^ cyclic type of infinite size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/new-solver/generalize/generalize-proj-new-universe-index-2.stderr b/tests/ui/traits/new-solver/generalize/generalize-proj-new-universe-index-2.stderr
index 9aa4f4531f9..b2a523ba620 100644
--- a/tests/ui/traits/new-solver/generalize/generalize-proj-new-universe-index-2.stderr
+++ b/tests/ui/traits/new-solver/generalize/generalize-proj-new-universe-index-2.stderr
@@ -13,6 +13,6 @@ LL | where
 LL |     T: WithAssoc<U, Assoc = V>,
    |                     ^^^^^^^^^ required by this bound in `bound`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/traits/new-solver/more-object-bound.stderr b/tests/ui/traits/new-solver/more-object-bound.stderr
index 54965dee184..e3be2931e12 100644
--- a/tests/ui/traits/new-solver/more-object-bound.stderr
+++ b/tests/ui/traits/new-solver/more-object-bound.stderr
@@ -17,6 +17,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn transmute<A, B>(x: A) -> B where dyn Trait<A = A, B = B>: Trait {
    |                               ++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/normalizes_to_ignores_unnormalizable_candidate.self_infer.stderr b/tests/ui/traits/new-solver/normalizes_to_ignores_unnormalizable_candidate.self_infer.stderr
index f482e8cfaf9..c1a8b74df08 100644
--- a/tests/ui/traits/new-solver/normalizes_to_ignores_unnormalizable_candidate.self_infer.stderr
+++ b/tests/ui/traits/new-solver/normalizes_to_ignores_unnormalizable_candidate.self_infer.stderr
@@ -17,6 +17,6 @@ help: consider specifying the generic argument
 LL |     foo::<T>(unconstrained())
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/new-solver/overflow/exponential-trait-goals.stderr b/tests/ui/traits/new-solver/overflow/exponential-trait-goals.stderr
index 023efc41aeb..90b54b1e789 100644
--- a/tests/ui/traits/new-solver/overflow/exponential-trait-goals.stderr
+++ b/tests/ui/traits/new-solver/overflow/exponential-trait-goals.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `impls`
 LL | fn impls<T: Trait>() {}
    |             ^^^^^ required by this bound in `impls`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/new-solver/overflow/global-cache.stderr b/tests/ui/traits/new-solver/overflow/global-cache.stderr
index ebb03d84b87..67616619384 100644
--- a/tests/ui/traits/new-solver/overflow/global-cache.stderr
+++ b/tests/ui/traits/new-solver/overflow/global-cache.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `impls_trait`
 LL | fn impls_trait<T: Trait>() {}
    |                   ^^^^^ required by this bound in `impls_trait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/new-solver/pointer-like.stderr b/tests/ui/traits/new-solver/pointer-like.stderr
index 215a81cc265..4b624fd0d35 100644
--- a/tests/ui/traits/new-solver/pointer-like.stderr
+++ b/tests/ui/traits/new-solver/pointer-like.stderr
@@ -19,6 +19,6 @@ LL |     require_(&1u16);
 LL |     require_(&mut 1u16);
    |              ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/projection-discr-kind.stderr b/tests/ui/traits/new-solver/projection-discr-kind.stderr
index e14953f19ff..69999c75522 100644
--- a/tests/ui/traits/new-solver/projection-discr-kind.stderr
+++ b/tests/ui/traits/new-solver/projection-discr-kind.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `needs_bar`
 LL | fn needs_bar(_: impl Bar) {}
    |                      ^^^ required by this bound in `needs_bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/stall-num-var-auto-trait.fallback.stderr b/tests/ui/traits/new-solver/stall-num-var-auto-trait.fallback.stderr
index a3ab7836c19..2e3c22c8d38 100644
--- a/tests/ui/traits/new-solver/stall-num-var-auto-trait.fallback.stderr
+++ b/tests/ui/traits/new-solver/stall-num-var-auto-trait.fallback.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `needs_foo`
 LL | fn needs_foo(x: impl Foo) {}
    |                      ^^^ required by this bound in `needs_foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/two-projection-param-candidates-are-ambiguous.stderr b/tests/ui/traits/new-solver/two-projection-param-candidates-are-ambiguous.stderr
index b311ac6b5a6..dfff9f11b87 100644
--- a/tests/ui/traits/new-solver/two-projection-param-candidates-are-ambiguous.stderr
+++ b/tests/ui/traits/new-solver/two-projection-param-candidates-are-ambiguous.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `needs_bar`
 LL | fn needs_bar<T: Bar>() {}
    |                 ^^^ required by this bound in `needs_bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/new-solver/unevaluated-const-impl-trait-ref.fails.stderr b/tests/ui/traits/new-solver/unevaluated-const-impl-trait-ref.fails.stderr
index 072ac32a5de..4be90c702a0 100644
--- a/tests/ui/traits/new-solver/unevaluated-const-impl-trait-ref.fails.stderr
+++ b/tests/ui/traits/new-solver/unevaluated-const-impl-trait-ref.fails.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `needs`
 LL | fn needs<const N: usize>() where (): Trait<N> {}
    |                                      ^^^^^^^^ required by this bound in `needs`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/new-solver/upcast-wrong-substs.stderr b/tests/ui/traits/new-solver/upcast-wrong-substs.stderr
index 7d16aaa9a16..00ba1ef678f 100644
--- a/tests/ui/traits/new-solver/upcast-wrong-substs.stderr
+++ b/tests/ui/traits/new-solver/upcast-wrong-substs.stderr
@@ -9,6 +9,6 @@ LL |     let y: &dyn Bar<usize> = x;
    = note: expected reference `&dyn Bar<usize>`
               found reference `&dyn Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/no-fallback-multiple-impls.stderr b/tests/ui/traits/no-fallback-multiple-impls.stderr
index 61c9e5aaabd..e38c432ca98 100644
--- a/tests/ui/traits/no-fallback-multiple-impls.stderr
+++ b/tests/ui/traits/no-fallback-multiple-impls.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `missing` in this scope
 LL |     missing();
    |     ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/traits/no_send-struct.stderr b/tests/ui/traits/no_send-struct.stderr
index ee7bdf282b7..fb7f26bb766 100644
--- a/tests/ui/traits/no_send-struct.stderr
+++ b/tests/ui/traits/no_send-struct.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `bar`
 LL | fn bar<T: Send>(_: T) {}
    |           ^^^^ required by this bound in `bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr b/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr
index 07e02d47f27..d5f2bfef192 100644
--- a/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr
+++ b/tests/ui/traits/non_lifetime_binders/bad-copy-cond.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `foo`
 LL | fn foo() where for<T> T: Copy {}
    |                          ^^^^ required by this bound in `foo`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/capture-late-ct-in-anon.stderr b/tests/ui/traits/non_lifetime_binders/capture-late-ct-in-anon.stderr
index d65892ec6df..4e0441c1c7d 100644
--- a/tests/ui/traits/non_lifetime_binders/capture-late-ct-in-anon.stderr
+++ b/tests/ui/traits/non_lifetime_binders/capture-late-ct-in-anon.stderr
@@ -15,5 +15,5 @@ LL |     for<const C: usize> [(); C]: Copy,
    |         |
    |         parameter defined here
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr
index a985b1a6e12..1f13207e33c 100644
--- a/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr
+++ b/tests/ui/traits/non_lifetime_binders/drop-impl-pred.no.stderr
@@ -19,6 +19,6 @@ note: the implementor must specify the same requirement
 LL | struct Bar<T>(T) where T: Foo;
    | ^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0367`.
diff --git a/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr b/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr
index da09343fb27..8cf32c89416 100644
--- a/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr
+++ b/tests/ui/traits/non_lifetime_binders/foreach-partial-eq.stderr
@@ -23,6 +23,6 @@ LL | where
 LL |     for<T> T: PartialEq + PartialOrd,
    |                           ^^^^^^^^^^ required by this bound in `auto_trait`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr b/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr
index dc54e1acc39..cc482887c81 100644
--- a/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr
+++ b/tests/ui/traits/non_lifetime_binders/late-bound-in-anon-ct.stderr
@@ -23,5 +23,5 @@ LL |     for<T> [i32; { let _: T = todo!(); 0 }]:,
    |         |
    |         parameter defined here
 
-error: aborting due to previous error; 2 warnings emitted
+error: aborting due to 1 previous error; 2 warnings emitted
 
diff --git a/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr b/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr
index d985386423d..eecf8e88fb6 100644
--- a/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr
+++ b/tests/ui/traits/non_lifetime_binders/missing-assoc-item.stderr
@@ -18,6 +18,6 @@ help: if there were a trait named `Example` with associated type `Item` implemen
 LL |     for<B> <B as Example>::Item: Send,
    |            ~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr b/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr
index 1124076c23c..83044691509 100644
--- a/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr
+++ b/tests/ui/traits/non_lifetime_binders/nested-apit-mentioning-outer-bound-var.stderr
@@ -13,5 +13,5 @@ error: `impl Trait` can only mention type parameters from an fn or impl
 LL | fn uwu(_: impl for<T> Trait<(), Assoc = impl Trait<T>>) {}
    |                    - type parameter declared here  ^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/traits/non_lifetime_binders/on-dyn.stderr b/tests/ui/traits/non_lifetime_binders/on-dyn.stderr
index 95656f99976..2d330f6b143 100644
--- a/tests/ui/traits/non_lifetime_binders/on-dyn.stderr
+++ b/tests/ui/traits/non_lifetime_binders/on-dyn.stderr
@@ -13,5 +13,5 @@ error: late-bound type parameter not allowed on trait object types
 LL | fn foo() -> &'static dyn for<T> Test<T> {
    |                              ^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/traits/non_lifetime_binders/on-ptr.stderr b/tests/ui/traits/non_lifetime_binders/on-ptr.stderr
index 3b17f7697b2..fbd723a1ba6 100644
--- a/tests/ui/traits/non_lifetime_binders/on-ptr.stderr
+++ b/tests/ui/traits/non_lifetime_binders/on-ptr.stderr
@@ -13,5 +13,5 @@ error: late-bound type parameter not allowed on function pointer types
 LL | fn foo() -> for<T> fn(T) {
    |                 ^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr
index e6c36129b28..7dd383b1e7a 100644
--- a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr
+++ b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.bad.stderr
@@ -21,6 +21,6 @@ help: consider adding an explicit lifetime bound
 LL | fn bad() where !1_"T": 'static {
    |          +++++++++++++++++++++
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr
index 31441ef4db8..b4f00978ada 100644
--- a/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr
+++ b/tests/ui/traits/non_lifetime_binders/placeholders-dont-outlive-static.good.stderr
@@ -21,6 +21,6 @@ help: consider adding an explicit lifetime bound
 LL | fn good() where for<T> T: 'static, !1_"T": 'static {
    |                                  +++++++++++++++++
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr b/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
index ddb6a798711..3a4415ed23a 100644
--- a/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
+++ b/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
@@ -21,6 +21,6 @@ help: consider adding an explicit lifetime bound
 LL |     for<F> F: 'a, !1_"F": 'a
    |                 ~~~~~~~~~~~~
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/traits/non_lifetime_binders/universe-error1.stderr b/tests/ui/traits/non_lifetime_binders/universe-error1.stderr
index bfcad72e352..ecc97e283be 100644
--- a/tests/ui/traits/non_lifetime_binders/universe-error1.stderr
+++ b/tests/ui/traits/non_lifetime_binders/universe-error1.stderr
@@ -22,6 +22,6 @@ LL | where
 LL |     for<T> T: Other<U> {}
    |               ^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/not-suggest-non-existing-fully-qualified-path.stderr b/tests/ui/traits/not-suggest-non-existing-fully-qualified-path.stderr
index 86ae49b32fc..1d5489845ef 100644
--- a/tests/ui/traits/not-suggest-non-existing-fully-qualified-path.stderr
+++ b/tests/ui/traits/not-suggest-non-existing-fully-qualified-path.stderr
@@ -24,6 +24,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     <A<B> as V<U>>::method(a);
    |     +++++++++++++++++++++++ ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/object-does-not-impl-trait.stderr b/tests/ui/traits/object-does-not-impl-trait.stderr
index 81d67255a0b..1ae05585174 100644
--- a/tests/ui/traits/object-does-not-impl-trait.stderr
+++ b/tests/ui/traits/object-does-not-impl-trait.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `take_foo`
 LL | fn take_foo<F:Foo>(f: F) {}
    |               ^^^ required by this bound in `take_foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/object/auto-dedup-in-impl.stderr b/tests/ui/traits/object/auto-dedup-in-impl.stderr
index 5f13c781341..075f3c33808 100644
--- a/tests/ui/traits/object/auto-dedup-in-impl.stderr
+++ b/tests/ui/traits/object/auto-dedup-in-impl.stderr
@@ -7,6 +7,6 @@ LL |     fn test(&self) { println!("one"); }
 LL |     fn test(&self) { println!("two"); }
    |     -------------- other definition for `test`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0592`.
diff --git a/tests/ui/traits/object/enforce-supertrait-projection.stderr b/tests/ui/traits/object/enforce-supertrait-projection.stderr
index 2fb94d34896..198a185dd48 100644
--- a/tests/ui/traits/object/enforce-supertrait-projection.stderr
+++ b/tests/ui/traits/object/enforce-supertrait-projection.stderr
@@ -21,6 +21,6 @@ LL | where
 LL |     T: Trait<B = B>,
    |        ^^^^^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/traits/object/issue-44454-1.stderr b/tests/ui/traits/object/issue-44454-1.stderr
index 859487f50ac..e85b4676931 100644
--- a/tests/ui/traits/object/issue-44454-1.stderr
+++ b/tests/ui/traits/object/issue-44454-1.stderr
@@ -6,5 +6,5 @@ LL | fn bar<'a>(_arg: &'a i32) {
 LL |     foo::<dyn Animal<&'a i32>, &'a i32>()
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/object/issue-44454-2.stderr b/tests/ui/traits/object/issue-44454-2.stderr
index 7f574769b7f..366b519aeb5 100644
--- a/tests/ui/traits/object/issue-44454-2.stderr
+++ b/tests/ui/traits/object/issue-44454-2.stderr
@@ -12,6 +12,6 @@ LL |     hr::<DynTrait, _>(x)
    |     `x` escapes the function body here
    |     argument requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/tests/ui/traits/object/issue-44454-3.stderr b/tests/ui/traits/object/issue-44454-3.stderr
index 294684d26bd..5b1ebf2d1a9 100644
--- a/tests/ui/traits/object/issue-44454-3.stderr
+++ b/tests/ui/traits/object/issue-44454-3.stderr
@@ -7,5 +7,5 @@ LL |     let x: <dyn Animal<&'a T> as Projector>::Foo = t;
 LL |     let any = generic::<dyn Animal<&'a T>, &'a T>(x);
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr b/tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr
index fcaa583e2bd..196e74d3960 100644
--- a/tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr
+++ b/tests/ui/traits/object/object-unsafe-missing-assoc-type.stderr
@@ -13,6 +13,6 @@ LL |     type Bar<T>;
    |          ^^^ ...because it contains the generic associated type `Bar`
    = help: consider moving `Bar` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/object/supertrait-lifetime-bound.stderr b/tests/ui/traits/object/supertrait-lifetime-bound.stderr
index ed2f8624357..4fd7d2f0ec7 100644
--- a/tests/ui/traits/object/supertrait-lifetime-bound.stderr
+++ b/tests/ui/traits/object/supertrait-lifetime-bound.stderr
@@ -7,5 +7,5 @@ LL | fn test2<'a>() {
 LL |     test1::<dyn Bar<&'a u32>, _>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/object/vs-lifetime-2.stderr b/tests/ui/traits/object/vs-lifetime-2.stderr
index 9b8e793dfd2..9a2bb7d1c98 100644
--- a/tests/ui/traits/object/vs-lifetime-2.stderr
+++ b/tests/ui/traits/object/vs-lifetime-2.stderr
@@ -4,6 +4,6 @@ error[E0224]: at least one trait is required for an object type
 LL |     dyn 'static +: 'static + Copy,
    |     ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0224`.
diff --git a/tests/ui/traits/overlap-not-permitted-for-builtin-trait.stderr b/tests/ui/traits/overlap-not-permitted-for-builtin-trait.stderr
index e24ed695dc5..d63362a7a60 100644
--- a/tests/ui/traits/overlap-not-permitted-for-builtin-trait.stderr
+++ b/tests/ui/traits/overlap-not-permitted-for-builtin-trait.stderr
@@ -6,6 +6,6 @@ LL | impl !Send for MyStruct {}
 LL | impl !Send for MyStruct {}
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyStruct`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/param-without-lifetime-constraint.stderr b/tests/ui/traits/param-without-lifetime-constraint.stderr
index b128b6518ce..b8ec1fa5654 100644
--- a/tests/ui/traits/param-without-lifetime-constraint.stderr
+++ b/tests/ui/traits/param-without-lifetime-constraint.stderr
@@ -15,5 +15,5 @@ help: the lifetime requirements from the `impl` do not correspond to the require
 LL |     fn get_relation(&self) -> To;
    |                               ^^ consider borrowing this type parameter in the trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/project-modulo-regions.with_clause.stderr b/tests/ui/traits/project-modulo-regions.with_clause.stderr
index dcc98e855d1..0e3081ddfdf 100644
--- a/tests/ui/traits/project-modulo-regions.with_clause.stderr
+++ b/tests/ui/traits/project-modulo-regions.with_clause.stderr
@@ -7,5 +7,5 @@ LL | fn test(val: MyStruct) where Helper: HelperTrait  {
 LL |     test(val);
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/project-modulo-regions.without_clause.stderr b/tests/ui/traits/project-modulo-regions.without_clause.stderr
index e9959567e06..830a07c4f5f 100644
--- a/tests/ui/traits/project-modulo-regions.without_clause.stderr
+++ b/tests/ui/traits/project-modulo-regions.without_clause.stderr
@@ -7,5 +7,5 @@ LL | fn test(val: MyStruct) where Helper: HelperTrait  {
 LL |     test(val);
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr b/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr
index 393350ea3f1..2b5277f9332 100644
--- a/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr
+++ b/tests/ui/traits/reservation-impl/coherence-conflict.next.stderr
@@ -8,6 +8,6 @@ LL | impl<T: MyTrait> OtherTrait for T {}
    |
    = note: this impl is reserved
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr b/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr
index 393350ea3f1..2b5277f9332 100644
--- a/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr
+++ b/tests/ui/traits/reservation-impl/coherence-conflict.old.stderr
@@ -8,6 +8,6 @@ LL | impl<T: MyTrait> OtherTrait for T {}
    |
    = note: this impl is reserved
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/reservation-impl/no-use.next.stderr b/tests/ui/traits/reservation-impl/no-use.next.stderr
index 632f0f81624..aa7b51dc5df 100644
--- a/tests/ui/traits/reservation-impl/no-use.next.stderr
+++ b/tests/ui/traits/reservation-impl/no-use.next.stderr
@@ -6,6 +6,6 @@ LL |     <() as MyTrait>::foo(&());
    |
    = help: the trait `MyTrait` is implemented for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/reservation-impl/no-use.old.stderr b/tests/ui/traits/reservation-impl/no-use.old.stderr
index 632f0f81624..aa7b51dc5df 100644
--- a/tests/ui/traits/reservation-impl/no-use.old.stderr
+++ b/tests/ui/traits/reservation-impl/no-use.old.stderr
@@ -6,6 +6,6 @@ LL |     <() as MyTrait>::foo(&());
    |
    = help: the trait `MyTrait` is implemented for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/resolution-in-overloaded-op.stderr b/tests/ui/traits/resolution-in-overloaded-op.stderr
index fe5e1d6d285..2f5408beb96 100644
--- a/tests/ui/traits/resolution-in-overloaded-op.stderr
+++ b/tests/ui/traits/resolution-in-overloaded-op.stderr
@@ -11,6 +11,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn foo<T: MyMul<f64, f64>>(a: &T, b: f64) -> f64 where &T: Mul<f64, Output = f64> {
    |                                                  ++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/traits/safety-fn-body.mir.stderr b/tests/ui/traits/safety-fn-body.mir.stderr
index ea7b2048e83..9a04f3e7d62 100644
--- a/tests/ui/traits/safety-fn-body.mir.stderr
+++ b/tests/ui/traits/safety-fn-body.mir.stderr
@@ -6,6 +6,6 @@ LL |         *self += 1;
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/traits/safety-fn-body.thir.stderr b/tests/ui/traits/safety-fn-body.thir.stderr
index 23696c32bef..5d4626c161e 100644
--- a/tests/ui/traits/safety-fn-body.thir.stderr
+++ b/tests/ui/traits/safety-fn-body.thir.stderr
@@ -6,6 +6,6 @@ LL |         *self += 1;
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/traits/safety-inherent-impl.stderr b/tests/ui/traits/safety-inherent-impl.stderr
index 1c8f43feca4..2513fef909e 100644
--- a/tests/ui/traits/safety-inherent-impl.stderr
+++ b/tests/ui/traits/safety-inherent-impl.stderr
@@ -6,6 +6,6 @@ LL | unsafe impl SomeStruct {
    | |
    | unsafe because of this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0197`.
diff --git a/tests/ui/traits/safety-trait-impl-cc.stderr b/tests/ui/traits/safety-trait-impl-cc.stderr
index 0ca565787f6..f530e5a769e 100644
--- a/tests/ui/traits/safety-trait-impl-cc.stderr
+++ b/tests/ui/traits/safety-trait-impl-cc.stderr
@@ -10,6 +10,6 @@ help: add `unsafe` to this trait implementation
 LL | unsafe impl lib::Foo for Bar {
    | ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0200`.
diff --git a/tests/ui/traits/self-without-lifetime-constraint.stderr b/tests/ui/traits/self-without-lifetime-constraint.stderr
index 05a49820a82..0a5ae8a027e 100644
--- a/tests/ui/traits/self-without-lifetime-constraint.stderr
+++ b/tests/ui/traits/self-without-lifetime-constraint.stderr
@@ -15,5 +15,5 @@ help: the lifetime requirements from the `impl` do not correspond to the require
 LL |     fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self, &Self>;
    |                                                            ^^^^ consider borrowing this type parameter in the trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/solver-cycles/cycle-via-builtin-auto-trait-impl.stderr b/tests/ui/traits/solver-cycles/cycle-via-builtin-auto-trait-impl.stderr
index 8f9ce3ef1e9..2ab150fc0f6 100644
--- a/tests/ui/traits/solver-cycles/cycle-via-builtin-auto-trait-impl.stderr
+++ b/tests/ui/traits/solver-cycles/cycle-via-builtin-auto-trait-impl.stderr
@@ -19,6 +19,6 @@ note: required because it appears within the type `Runtime<RootDatabase>`
 LL | struct Runtime<DB: Database> {
    |        ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/static-method-generic-inference.stderr b/tests/ui/traits/static-method-generic-inference.stderr
index 575ace2374e..44c7c099832 100644
--- a/tests/ui/traits/static-method-generic-inference.stderr
+++ b/tests/ui/traits/static-method-generic-inference.stderr
@@ -12,6 +12,6 @@ help: use the fully-qualified path to the only available implementation
 LL |     let _f: base::Foo = <Foo as base::HasNew>::new();
    |                         +++++++             +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/traits/staticness-mismatch.stderr b/tests/ui/traits/staticness-mismatch.stderr
index b67ac5adbe1..3546cb70555 100644
--- a/tests/ui/traits/staticness-mismatch.stderr
+++ b/tests/ui/traits/staticness-mismatch.stderr
@@ -7,6 +7,6 @@ LL |     fn bar();
 LL |     fn bar(&self) {}
    |     ^^^^^^^^^^^^^ `&self` used in impl
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0185`.
diff --git a/tests/ui/traits/suggest-dereferences/dont-suggest-unsize-deref.stderr b/tests/ui/traits/suggest-dereferences/dont-suggest-unsize-deref.stderr
index bd0e7ca2c02..8024ad28d5a 100644
--- a/tests/ui/traits/suggest-dereferences/dont-suggest-unsize-deref.stderr
+++ b/tests/ui/traits/suggest-dereferences/dont-suggest-unsize-deref.stderr
@@ -17,6 +17,6 @@ LL | where
 LL |     I: IntoIterator<Item = i32>,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `use_iterator`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-dereferences/issue-39029.stderr b/tests/ui/traits/suggest-dereferences/issue-39029.stderr
index 49105de3d69..fd45fa3cf74 100644
--- a/tests/ui/traits/suggest-dereferences/issue-39029.stderr
+++ b/tests/ui/traits/suggest-dereferences/issue-39029.stderr
@@ -14,6 +14,6 @@ help: consider dereferencing here
 LL |     let _errors = TcpListener::bind(&*bad);
    |                                      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-dereferences/issue-62530.stderr b/tests/ui/traits/suggest-dereferences/issue-62530.stderr
index e47ae0b65af..22b001c8001 100644
--- a/tests/ui/traits/suggest-dereferences/issue-62530.stderr
+++ b/tests/ui/traits/suggest-dereferences/issue-62530.stderr
@@ -16,6 +16,6 @@ help: consider dereferencing here
 LL |     takes_type_parameter(&*string);  // Error
    |                           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-dereferences/multiple-0.stderr b/tests/ui/traits/suggest-dereferences/multiple-0.stderr
index 6a4d4b8d521..691b4ddc8e1 100644
--- a/tests/ui/traits/suggest-dereferences/multiple-0.stderr
+++ b/tests/ui/traits/suggest-dereferences/multiple-0.stderr
@@ -16,6 +16,6 @@ help: consider dereferencing here
 LL |     foo(&***baz);
    |          +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-dereferences/multiple-1.stderr b/tests/ui/traits/suggest-dereferences/multiple-1.stderr
index 6e12321c233..2517cc6a02c 100644
--- a/tests/ui/traits/suggest-dereferences/multiple-1.stderr
+++ b/tests/ui/traits/suggest-dereferences/multiple-1.stderr
@@ -13,6 +13,6 @@ note: required by a bound in `foo`
 LL | fn foo<T>(_: T) where T: Happy {}
    |                          ^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-dereferences/root-obligation.stderr b/tests/ui/traits/suggest-dereferences/root-obligation.stderr
index a19708e46bb..62500866c49 100644
--- a/tests/ui/traits/suggest-dereferences/root-obligation.stderr
+++ b/tests/ui/traits/suggest-dereferences/root-obligation.stderr
@@ -16,6 +16,6 @@ help: consider dereferencing here
 LL |         .filter(|c| "aeiou".contains(*c))
    |                                      +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-dereferences/suggest-dereferencing-receiver-argument.stderr b/tests/ui/traits/suggest-dereferences/suggest-dereferencing-receiver-argument.stderr
index ede31a2c7bc..d6033bc6baa 100644
--- a/tests/ui/traits/suggest-dereferences/suggest-dereferencing-receiver-argument.stderr
+++ b/tests/ui/traits/suggest-dereferences/suggest-dereferencing-receiver-argument.stderr
@@ -10,6 +10,6 @@ help: consider dereferencing here
 LL |     let _b: TargetStruct = (*a).into();
    |                            ++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/suggest-fully-qualified-closure.stderr b/tests/ui/traits/suggest-fully-qualified-closure.stderr
index 43cef7027a2..e077bd7ac2a 100644
--- a/tests/ui/traits/suggest-fully-qualified-closure.stderr
+++ b/tests/ui/traits/suggest-fully-qualified-closure.stderr
@@ -17,6 +17,6 @@ help: try using a fully qualified path to specify the expected types
 LL |     <Qqq as MyTrait<T>>::lol::<{closure@}>(&q, ||());
    |     +++ ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/traits/test.stderr b/tests/ui/traits/test.stderr
index 668228abe09..af005db5880 100644
--- a/tests/ui/traits/test.stderr
+++ b/tests/ui/traits/test.stderr
@@ -4,6 +4,6 @@ error[E0404]: expected trait, found builtin type `isize`
 LL | impl isize for usize { fn foo(&self) {} }
    |      ^^^^^ not a trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/traits/trait-object-lifetime-default-note.stderr b/tests/ui/traits/trait-object-lifetime-default-note.stderr
index b6dd6753899..4244e34873a 100644
--- a/tests/ui/traits/trait-object-lifetime-default-note.stderr
+++ b/tests/ui/traits/trait-object-lifetime-default-note.stderr
@@ -14,6 +14,6 @@ LL | }
    |
    = note: due to object lifetime defaults, `Box<dyn A>` actually means `Box<(dyn A + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/traits/trait-or-new-type-instead.stderr b/tests/ui/traits/trait-or-new-type-instead.stderr
index 6fd8a03fd8f..17ee9398878 100644
--- a/tests/ui/traits/trait-or-new-type-instead.stderr
+++ b/tests/ui/traits/trait-or-new-type-instead.stderr
@@ -6,6 +6,6 @@ LL | impl<T> Option<T> {
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0116`.
diff --git a/tests/ui/traits/trait-upcasting/alias-where-clause-isnt-supertrait.stderr b/tests/ui/traits/trait-upcasting/alias-where-clause-isnt-supertrait.stderr
index c4f00c9f55f..1a410519a4e 100644
--- a/tests/ui/traits/trait-upcasting/alias-where-clause-isnt-supertrait.stderr
+++ b/tests/ui/traits/trait-upcasting/alias-where-clause-isnt-supertrait.stderr
@@ -9,6 +9,6 @@ LL |     x
    = note: expected reference `&dyn B`
               found reference `&dyn C`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/cyclic-trait-resolution.stderr b/tests/ui/traits/trait-upcasting/cyclic-trait-resolution.stderr
index 62c732fb1d9..85c05bd05db 100644
--- a/tests/ui/traits/trait-upcasting/cyclic-trait-resolution.stderr
+++ b/tests/ui/traits/trait-upcasting/cyclic-trait-resolution.stderr
@@ -12,6 +12,6 @@ LL | trait A: B + A {}
    | ^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr b/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr
index e8bab322a38..193d09e3501 100644
--- a/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr
+++ b/tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr
@@ -11,6 +11,6 @@ help: you can convert an `i32` to a `u32` and panic if the converted value doesn
 LL |     let z: u32 = y.try_into().unwrap();
    |                   ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.current.stderr b/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.current.stderr
index a1b671b4a32..119b3109c63 100644
--- a/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.current.stderr
+++ b/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.current.stderr
@@ -9,6 +9,6 @@ LL | fn illegal(x: &dyn Sub<Assoc = ()>) -> &dyn Super<Assoc = i32> { x }
    = note: expected reference `&dyn Super<Assoc = i32>`
               found reference `&dyn Sub<Assoc = ()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.next.stderr b/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.next.stderr
index a1b671b4a32..119b3109c63 100644
--- a/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.next.stderr
+++ b/tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.next.stderr
@@ -9,6 +9,6 @@ LL | fn illegal(x: &dyn Sub<Assoc = ()>) -> &dyn Super<Assoc = i32> { x }
    = note: expected reference `&dyn Super<Assoc = i32>`
               found reference `&dyn Sub<Assoc = ()>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/inference-behavior-change-deref.stderr b/tests/ui/traits/trait-upcasting/inference-behavior-change-deref.stderr
index 48d331e81b0..fcc80c6148f 100644
--- a/tests/ui/traits/trait-upcasting/inference-behavior-change-deref.stderr
+++ b/tests/ui/traits/trait-upcasting/inference-behavior-change-deref.stderr
@@ -11,6 +11,6 @@ help: you can convert an `i32` to a `u32` and panic if the converted value doesn
 LL |     let z: u32 = y.try_into().unwrap();
    |                   ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/multiple-occurrence-ambiguousity.stderr b/tests/ui/traits/trait-upcasting/multiple-occurrence-ambiguousity.stderr
index ea44a81e2a7..c888ccc1ebb 100644
--- a/tests/ui/traits/trait-upcasting/multiple-occurrence-ambiguousity.stderr
+++ b/tests/ui/traits/trait-upcasting/multiple-occurrence-ambiguousity.stderr
@@ -9,6 +9,6 @@ LL |     let t: &dyn Bar<_> = s;
    = note: expected reference `&dyn Bar<_>`
               found reference `&dyn Foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/trait-upcasting/multiple_supertrait_upcastable.stderr b/tests/ui/traits/trait-upcasting/multiple_supertrait_upcastable.stderr
index ad80a009ece..d075102b2e8 100644
--- a/tests/ui/traits/trait-upcasting/multiple_supertrait_upcastable.stderr
+++ b/tests/ui/traits/trait-upcasting/multiple_supertrait_upcastable.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(multiple_supertrait_upcastable)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/trait-upcasting/type-checking-test-1.current.stderr b/tests/ui/traits/trait-upcasting/type-checking-test-1.current.stderr
index bcba37cab78..47ffa68b8ff 100644
--- a/tests/ui/traits/trait-upcasting/type-checking-test-1.current.stderr
+++ b/tests/ui/traits/trait-upcasting/type-checking-test-1.current.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `&dyn Foo` as `&dyn Bar<_>`
 LL |     let _ = x as &dyn Bar<_>; // Ambiguous
    |             ^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/traits/trait-upcasting/type-checking-test-1.next.stderr b/tests/ui/traits/trait-upcasting/type-checking-test-1.next.stderr
index bcba37cab78..47ffa68b8ff 100644
--- a/tests/ui/traits/trait-upcasting/type-checking-test-1.next.stderr
+++ b/tests/ui/traits/trait-upcasting/type-checking-test-1.next.stderr
@@ -4,6 +4,6 @@ error[E0605]: non-primitive cast: `&dyn Foo` as `&dyn Bar<_>`
 LL |     let _ = x as &dyn Bar<_>; // Ambiguous
    |             ^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/traits/trivial_impl.stderr b/tests/ui/traits/trivial_impl.stderr
index 4b29b55bea1..68dbf5dd4e8 100644
--- a/tests/ui/traits/trivial_impl.stderr
+++ b/tests/ui/traits/trivial_impl.stderr
@@ -9,6 +9,6 @@ LL | |         Self: Foo<()>;
 LL |   impl Foo<u32> for () {}
    |   ^^^^^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/traits/trivial_impl2.stderr b/tests/ui/traits/trivial_impl2.stderr
index 04c05df0616..9a220d24f3d 100644
--- a/tests/ui/traits/trivial_impl2.stderr
+++ b/tests/ui/traits/trivial_impl2.stderr
@@ -9,6 +9,6 @@ LL | |         Self: Foo<()>;
 LL |   impl Foo<u32> for () {}
    |   ^^^^^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/traits/trivial_impl3.stderr b/tests/ui/traits/trivial_impl3.stderr
index dfb39d6ce15..5aa1a4a3c32 100644
--- a/tests/ui/traits/trivial_impl3.stderr
+++ b/tests/ui/traits/trivial_impl3.stderr
@@ -9,6 +9,6 @@ LL | |         Self: trivial3::Trait;
 LL |   impl Foo for u8 {}
    |   ^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/traits/trivial_impl4.stderr b/tests/ui/traits/trivial_impl4.stderr
index 04b29ed7734..2e86be730cc 100644
--- a/tests/ui/traits/trivial_impl4.stderr
+++ b/tests/ui/traits/trivial_impl4.stderr
@@ -9,6 +9,6 @@ LL | |         Self: trivial4::Trait;
 LL |   impl Foo for u8 {}
    |   ^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/traits/unsend-future.stderr b/tests/ui/traits/unsend-future.stderr
index 01829021b4a..25df3419794 100644
--- a/tests/ui/traits/unsend-future.stderr
+++ b/tests/ui/traits/unsend-future.stderr
@@ -18,5 +18,5 @@ note: required by a bound in `require_handler`
 LL | fn require_handler<H: Handler>(h: H) {}
    |                       ^^^^^^^ required by this bound in `require_handler`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/vtable-res-trait-param.stderr b/tests/ui/traits/vtable-res-trait-param.stderr
index 4cfceefb24c..fff602b8d2b 100644
--- a/tests/ui/traits/vtable-res-trait-param.stderr
+++ b/tests/ui/traits/vtable-res-trait-param.stderr
@@ -17,6 +17,6 @@ note: required by a bound in `TraitB::gimme_an_a`
 LL |     fn gimme_an_a<A:TraitA>(&self, a: A) -> isize;
    |                     ^^^^^^ required by this bound in `TraitB::gimme_an_a`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/vtable/issue-97381.stderr b/tests/ui/traits/vtable/issue-97381.stderr
index 89360c44e78..503d0f12521 100644
--- a/tests/ui/traits/vtable/issue-97381.stderr
+++ b/tests/ui/traits/vtable/issue-97381.stderr
@@ -13,6 +13,6 @@ LL |
 LL |         println!("{}", ***el > 0);
    |                         ---- borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/traits/vtable/vtable-non-object-safe.stderr b/tests/ui/traits/vtable/vtable-non-object-safe.stderr
index 9345c271197..53eef5d0b13 100644
--- a/tests/ui/traits/vtable/vtable-non-object-safe.stderr
+++ b/tests/ui/traits/vtable/vtable-non-object-safe.stderr
@@ -12,5 +12,5 @@ error: vtable entries for `<std::vec::IntoIter<u8> as A>`: [
 LL | trait A: Iterator {}
    | ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/vtable/vtable-vacant.stderr b/tests/ui/traits/vtable/vtable-vacant.stderr
index 5346a702716..9ce1d0b7632 100644
--- a/tests/ui/traits/vtable/vtable-vacant.stderr
+++ b/tests/ui/traits/vtable/vtable-vacant.stderr
@@ -12,5 +12,5 @@ error: vtable entries for `<S as B>`: [
 LL | trait B: A {
    | ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/alignment/align-fail.stderr b/tests/ui/transmutability/alignment/align-fail.stderr
index 59246fb1b03..c68c1481f4d 100644
--- a/tests/ui/transmutability/alignment/align-fail.stderr
+++ b/tests/ui/transmutability/alignment/align-fail.stderr
@@ -25,6 +25,6 @@ LL -     assert::is_maybe_transmutable::<&'static [u8; 0], &'static [u16; 0]>();
 LL +     assert::is_maybe_transmutable::<&'static [u8; 0], [u16; 0]>();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/arrays/issue-103783-array-length.stderr b/tests/ui/transmutability/arrays/issue-103783-array-length.stderr
index 37774c59e6c..2c581664f39 100644
--- a/tests/ui/transmutability/arrays/issue-103783-array-length.stderr
+++ b/tests/ui/transmutability/arrays/issue-103783-array-length.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     type NaughtyLenArray = [u32; 3.14159];
    |                                  ^^^^^^^ expected `usize`, found floating-point number
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/transmutability/enums/should_pad_variants.stderr b/tests/ui/transmutability/enums/should_pad_variants.stderr
index bfbef8b25fc..fd98e355fb9 100644
--- a/tests/ui/transmutability/enums/should_pad_variants.stderr
+++ b/tests/ui/transmutability/enums/should_pad_variants.stderr
@@ -19,6 +19,6 @@ LL | |                 .and(Assume::VALIDITY)
 LL | |         }>
    | |__________^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/enums/should_respect_endianness.stderr b/tests/ui/transmutability/enums/should_respect_endianness.stderr
index e59301a8ce9..8823f40e534 100644
--- a/tests/ui/transmutability/enums/should_respect_endianness.stderr
+++ b/tests/ui/transmutability/enums/should_respect_endianness.stderr
@@ -19,6 +19,6 @@ LL | |                 .and(Assume::VALIDITY)
 LL | |         }>
    | |__________^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/issue-101739-2.stderr b/tests/ui/transmutability/issue-101739-2.stderr
index 420a9f33008..d5ed205d14b 100644
--- a/tests/ui/transmutability/issue-101739-2.stderr
+++ b/tests/ui/transmutability/issue-101739-2.stderr
@@ -9,6 +9,6 @@ LL | |             ASSUME_VALIDITY,
 LL | |             ASSUME_VISIBILITY,
    | |_____________________________- help: remove these generic arguments
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.stderr b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.stderr
index b4591778f8e..10e057ec104 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.stderr
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.stderr
@@ -9,6 +9,6 @@ help: you might be missing a type parameter
 LL | fn should_gracefully_handle_unknown_dst<Dst>() {
    |                                        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.stderr b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.stderr
index a55d71d8068..a84d2726fa9 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.stderr
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.stderr
@@ -9,6 +9,6 @@ help: you might be missing a type parameter
 LL | fn should_gracefully_handle_unknown_src<Src>() {
    |                                        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/transmutability/primitives/bool-mut.stderr b/tests/ui/transmutability/primitives/bool-mut.stderr
index b36991e1c01..62a7a2b8622 100644
--- a/tests/ui/transmutability/primitives/bool-mut.stderr
+++ b/tests/ui/transmutability/primitives/bool-mut.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/primitives/bool.current.stderr b/tests/ui/transmutability/primitives/bool.current.stderr
index 4b3eb6c517d..6dfd83dd514 100644
--- a/tests/ui/transmutability/primitives/bool.current.stderr
+++ b/tests/ui/transmutability/primitives/bool.current.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/primitives/bool.next.stderr b/tests/ui/transmutability/primitives/bool.next.stderr
index 4b3eb6c517d..6dfd83dd514 100644
--- a/tests/ui/transmutability/primitives/bool.next.stderr
+++ b/tests/ui/transmutability/primitives/bool.next.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/primitives/unit.current.stderr b/tests/ui/transmutability/primitives/unit.current.stderr
index c49eb6097bd..e5d8466c323 100644
--- a/tests/ui/transmutability/primitives/unit.current.stderr
+++ b/tests/ui/transmutability/primitives/unit.current.stderr
@@ -19,6 +19,6 @@ LL | |                 .and(Assume::VALIDITY)
 LL | |         }>
    | |__________^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/primitives/unit.next.stderr b/tests/ui/transmutability/primitives/unit.next.stderr
index c49eb6097bd..e5d8466c323 100644
--- a/tests/ui/transmutability/primitives/unit.next.stderr
+++ b/tests/ui/transmutability/primitives/unit.next.stderr
@@ -19,6 +19,6 @@ LL | |                 .and(Assume::VALIDITY)
 LL | |         }>
    | |__________^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.stderr b/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.stderr
index 4b4d6ad0298..8b22f89c7ef 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.stderr
+++ b/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.stderr
@@ -20,6 +20,6 @@ LL | |             }
 LL | |         }>
    | |__________^ required by this bound in `is_maybe_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr b/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr
index ecfe4865962..982af825918 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr
+++ b/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr
@@ -20,6 +20,6 @@ LL | |             }
 LL | |         }>
    | |__________^ required by this bound in `is_maybe_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/references/unit-to-u8.stderr b/tests/ui/transmutability/references/unit-to-u8.stderr
index f2b72357f79..a0891dfd01e 100644
--- a/tests/ui/transmutability/references/unit-to-u8.stderr
+++ b/tests/ui/transmutability/references/unit-to-u8.stderr
@@ -20,6 +20,6 @@ LL | |             }
 LL | |         }>
    | |__________^ required by this bound in `is_maybe_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/region-infer.stderr b/tests/ui/transmutability/region-infer.stderr
index 307d0dfe50d..50d060cd474 100644
--- a/tests/ui/transmutability/region-infer.stderr
+++ b/tests/ui/transmutability/region-infer.stderr
@@ -18,6 +18,6 @@ LL | |             { Assume { alignment: true, lifetimes: true, safety: true, va
 LL | |         >,
    | |_________^ required by this bound in `test`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/unions/should_pad_variants.stderr b/tests/ui/transmutability/unions/should_pad_variants.stderr
index bfbef8b25fc..fd98e355fb9 100644
--- a/tests/ui/transmutability/unions/should_pad_variants.stderr
+++ b/tests/ui/transmutability/unions/should_pad_variants.stderr
@@ -19,6 +19,6 @@ LL | |                 .and(Assume::VALIDITY)
 LL | |         }>
    | |__________^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/unions/should_reject_contraction.stderr b/tests/ui/transmutability/unions/should_reject_contraction.stderr
index 553f655a10a..e3493e18489 100644
--- a/tests/ui/transmutability/unions/should_reject_contraction.stderr
+++ b/tests/ui/transmutability/unions/should_reject_contraction.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr
index 827df05decb..cf94d72b883 100644
--- a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr
@@ -10,6 +10,6 @@ note: the struct `Dst` is defined here
 LL |     #[repr(C)] pub(self) struct Dst {
    |                ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/transmutability/visibility/should_accept_if_src_has_unreachable_ty.stderr b/tests/ui/transmutability/visibility/should_accept_if_src_has_unreachable_ty.stderr
index 76dc7f34075..57ceac61f16 100644
--- a/tests/ui/transmutability/visibility/should_accept_if_src_has_unreachable_ty.stderr
+++ b/tests/ui/transmutability/visibility/should_accept_if_src_has_unreachable_ty.stderr
@@ -10,6 +10,6 @@ note: the struct `Src` is defined here
 LL |     #[repr(C)] pub(self) struct Src {
    |                ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr
index 863ada3c2c4..cb2e7ec29a5 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_field.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr
index 7b0f1b4d56e..434c3fcd278 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_private_variant.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr b/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr
index df19477ef26..e987aa595b9 100644
--- a/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr
+++ b/tests/ui/transmutability/visibility/should_reject_if_dst_has_unreachable_field.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src, Context> // safety is NOT assumed
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmute/transmute-impl.stderr b/tests/ui/transmute/transmute-impl.stderr
index dd19bcd54e3..6ed1cd6cec4 100644
--- a/tests/ui/transmute/transmute-impl.stderr
+++ b/tests/ui/transmute/transmute-impl.stderr
@@ -7,6 +7,6 @@ LL |         unsafe { transmute(x) }
    = note: source type: `&T` (pointer to `T`)
    = note: target type: `&isize` (N bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/transmute/transmute-imut-to-mut.stderr b/tests/ui/transmute/transmute-imut-to-mut.stderr
index 1e9dff3ce89..d37050fa58a 100644
--- a/tests/ui/transmute/transmute-imut-to-mut.stderr
+++ b/tests/ui/transmute/transmute-imut-to-mut.stderr
@@ -6,5 +6,5 @@ LL |     let _a: &mut u8 = unsafe { transmute(&1u8) };
    |
    = note: `#[deny(mutable_transmutes)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmute/transmute-padding-ice.stderr b/tests/ui/transmute/transmute-padding-ice.stderr
index f5480e0b9fb..ff5c5c3a5dd 100644
--- a/tests/ui/transmute/transmute-padding-ice.stderr
+++ b/tests/ui/transmute/transmute-padding-ice.stderr
@@ -18,6 +18,6 @@ LL | |             { Assume { alignment: true, lifetimes: true, safety: true, va
 LL | |         >,
    | |_________^ required by this bound in `is_maybe_transmutable`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/trivial-bounds/trivial-bounds-inconsistent-projection-error.stderr b/tests/ui/trivial-bounds/trivial-bounds-inconsistent-projection-error.stderr
index 26679e71380..554b3a64cc2 100644
--- a/tests/ui/trivial-bounds/trivial-bounds-inconsistent-projection-error.stderr
+++ b/tests/ui/trivial-bounds/trivial-bounds-inconsistent-projection-error.stderr
@@ -12,6 +12,6 @@ help: you can convert an `i32` to a `u8` and panic if the converted value doesn'
 LL |     B::get_x().try_into().unwrap()
    |               ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/trivial-bounds/trivial-bounds-leak-copy.stderr b/tests/ui/trivial-bounds/trivial-bounds-leak-copy.stderr
index b3ec3cd8d9d..e48d48a7271 100644
--- a/tests/ui/trivial-bounds/trivial-bounds-leak-copy.stderr
+++ b/tests/ui/trivial-bounds/trivial-bounds-leak-copy.stderr
@@ -4,6 +4,6 @@ error[E0507]: cannot move out of `*t` which is behind a shared reference
 LL |     *t
    |     ^^ move occurs because `*t` has type `String`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/try-block/try-block-catch.stderr b/tests/ui/try-block/try-block-catch.stderr
index 39cf943f4d8..185bcb4071b 100644
--- a/tests/ui/try-block/try-block-catch.stderr
+++ b/tests/ui/try-block/try-block-catch.stderr
@@ -6,5 +6,5 @@ LL |     } catch { };
    |
    = help: try using `match` on the result of the `try` block instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/try-block/try-block-in-while.stderr b/tests/ui/try-block/try-block-in-while.stderr
index 62cc26dd401..2760e930102 100644
--- a/tests/ui/try-block/try-block-in-while.stderr
+++ b/tests/ui/try-block/try-block-in-while.stderr
@@ -6,6 +6,6 @@ LL |     while try { false } {}
    |
    = help: the trait `Try` is not implemented for `bool`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/try-block/try-block-opt-init.stderr b/tests/ui/try-block/try-block-opt-init.stderr
index c397385017f..1679fc2ac18 100644
--- a/tests/ui/try-block/try-block-opt-init.stderr
+++ b/tests/ui/try-block/try-block-opt-init.stderr
@@ -12,6 +12,6 @@ LL |     assert_eq!(cfg_res, 5);
    |
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/try-trait/issue-32709.stderr b/tests/ui/try-trait/issue-32709.stderr
index 94e8f9295fd..46798f5dcfd 100644
--- a/tests/ui/try-trait/issue-32709.stderr
+++ b/tests/ui/try-trait/issue-32709.stderr
@@ -19,6 +19,6 @@ LL |     Err(5)?;
            and 4 others
    = note: required for `Result<i32, ()>` to implement `FromResidual<Result<Infallible, {integer}>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/tuple/array-diagnostics.stderr b/tests/ui/tuple/array-diagnostics.stderr
index a10d7af470c..629ca2b37fa 100644
--- a/tests/ui/tuple/array-diagnostics.stderr
+++ b/tests/ui/tuple/array-diagnostics.stderr
@@ -4,6 +4,6 @@ error[E0618]: expected function, found `(&'static str, {integer})`
 LL |         ("C200B40A83", 4)
    |         ^^^^^^^^^^^^^^^^^- help: consider separating array elements with a comma: `,`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/tuple/wrong_argument_ice-2.stderr b/tests/ui/tuple/wrong_argument_ice-2.stderr
index 41244209214..a868adf411b 100644
--- a/tests/ui/tuple/wrong_argument_ice-2.stderr
+++ b/tests/ui/tuple/wrong_argument_ice-2.stderr
@@ -14,6 +14,6 @@ help: wrap these arguments in parentheses to construct a tuple
 LL |     test((x.qux(), x.qux()));
    |          +                +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/tuple/wrong_argument_ice-3.stderr b/tests/ui/tuple/wrong_argument_ice-3.stderr
index 8b9dac6e291..ce21751f39d 100644
--- a/tests/ui/tuple/wrong_argument_ice-3.stderr
+++ b/tests/ui/tuple/wrong_argument_ice-3.stderr
@@ -19,6 +19,6 @@ LL -         groups.push(new_group, vec![process]);
 LL +         groups.push(/* (Vec<String>, Vec<Process>) */);
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/tuple/wrong_argument_ice-4.stderr b/tests/ui/tuple/wrong_argument_ice-4.stderr
index 1fbf180c673..3c7d6699be2 100644
--- a/tests/ui/tuple/wrong_argument_ice-4.stderr
+++ b/tests/ui/tuple/wrong_argument_ice-4.stderr
@@ -17,6 +17,6 @@ note: closure defined here
 LL |     (|| {})(|| {
    |      ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0057`.
diff --git a/tests/ui/tuple/wrong_argument_ice.stderr b/tests/ui/tuple/wrong_argument_ice.stderr
index 213ca8f885c..6d0558d2876 100644
--- a/tests/ui/tuple/wrong_argument_ice.stderr
+++ b/tests/ui/tuple/wrong_argument_ice.stderr
@@ -11,6 +11,6 @@ help: wrap these arguments in parentheses to construct a tuple
 LL |         self.acc.push_back((self.current_provides, self.current_requires));
    |                            +                                            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-Self-issue-58006.stderr b/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-Self-issue-58006.stderr
index 6870b9d7d09..2e6136eb959 100644
--- a/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-Self-issue-58006.stderr
+++ b/tests/ui/type-alias-enum-variants/incorrect-variant-form-through-Self-issue-58006.stderr
@@ -4,6 +4,6 @@ error[E0533]: expected unit struct, unit variant or constant, found tuple varian
 LL |             Self::A => (),
    |             ^^^^^^^ not a unit struct, unit variant or constant
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0533`.
diff --git a/tests/ui/type-alias-enum-variants/no-type-application-on-aliased-enum-variant.stderr b/tests/ui/type-alias-enum-variants/no-type-application-on-aliased-enum-variant.stderr
index 51b1c8a1068..3c143f34216 100644
--- a/tests/ui/type-alias-enum-variants/no-type-application-on-aliased-enum-variant.stderr
+++ b/tests/ui/type-alias-enum-variants/no-type-application-on-aliased-enum-variant.stderr
@@ -6,6 +6,6 @@ LL |     let _ = Alias::None::<u8>;
    |                    |
    |                    not allowed on this type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/type-alias-enum-variants/resolve-to-enum-variant-in-type-namespace-and-error.stderr b/tests/ui/type-alias-enum-variants/resolve-to-enum-variant-in-type-namespace-and-error.stderr
index f190bfb6983..7ddcc318f88 100644
--- a/tests/ui/type-alias-enum-variants/resolve-to-enum-variant-in-type-namespace-and-error.stderr
+++ b/tests/ui/type-alias-enum-variants/resolve-to-enum-variant-in-type-namespace-and-error.stderr
@@ -4,5 +4,5 @@ error: expected type, found variant `V`
 LL | fn check() -> <E>::V {}
    |               ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-enum-variants/self-in-enum-definition.stderr b/tests/ui/type-alias-enum-variants/self-in-enum-definition.stderr
index aa79b1a57c4..404e376e364 100644
--- a/tests/ui/type-alias-enum-variants/self-in-enum-definition.stderr
+++ b/tests/ui/type-alias-enum-variants/self-in-enum-definition.stderr
@@ -69,6 +69,6 @@ LL | | fn main() {}
    | |____________^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/type-alias-impl-trait/assoc-type-lifetime-unconstrained.stderr b/tests/ui/type-alias-impl-trait/assoc-type-lifetime-unconstrained.stderr
index e594dc577b1..089c3e4fd8a 100644
--- a/tests/ui/type-alias-impl-trait/assoc-type-lifetime-unconstrained.stderr
+++ b/tests/ui/type-alias-impl-trait/assoc-type-lifetime-unconstrained.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a, I> UnwrapItemsExt for I {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/auto-trait-leakage2.stderr b/tests/ui/type-alias-impl-trait/auto-trait-leakage2.stderr
index d7247302dd1..2ed918eca17 100644
--- a/tests/ui/type-alias-impl-trait/auto-trait-leakage2.stderr
+++ b/tests/ui/type-alias-impl-trait/auto-trait-leakage2.stderr
@@ -21,6 +21,6 @@ note: required by a bound in `is_send`
 LL | fn is_send<T: Send>(_: T) {}
    |               ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/auto-trait-leakage3.stderr b/tests/ui/type-alias-impl-trait/auto-trait-leakage3.stderr
index d47b1fe3678..f6f75455799 100644
--- a/tests/ui/type-alias-impl-trait/auto-trait-leakage3.stderr
+++ b/tests/ui/type-alias-impl-trait/auto-trait-leakage3.stderr
@@ -22,5 +22,5 @@ note: required by a bound in `is_send`
 LL |     fn is_send<T: Send>(_: T) {}
    |                   ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
index 8678e9b33b5..20e478160c6 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked-2.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | type X<T: std::clone::Clone> = impl Clone;
    |         +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked.stderr
index 962dedde09a..ad1b9f19d8e 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked.stderr
@@ -7,6 +7,6 @@ LL | type X<'a> = impl Into<&'static str> + From<&'a str>;
 LL |     t
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0792`.
diff --git a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
index a845cba7716..bca88b5fae1 100644
--- a/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
+++ b/tests/ui/type-alias-impl-trait/bounds-are-checked3.stderr
@@ -15,6 +15,6 @@ help: consider further restricting this bound
 LL | type Foo<T: Debug + std::fmt::Display> = (impl Debug, Struct<T>);
    |                   +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/coherence.stderr b/tests/ui/type-alias-impl-trait/coherence.stderr
index 36bbb985ef0..4462b70f782 100644
--- a/tests/ui/type-alias-impl-trait/coherence.stderr
+++ b/tests/ui/type-alias-impl-trait/coherence.stderr
@@ -9,6 +9,6 @@ LL | impl foreign_crate::ForeignTrait for AliasOfForeignType<()> {}
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr b/tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr
index 63a3ce29cc7..893a27faced 100644
--- a/tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr
+++ b/tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr
@@ -8,6 +8,6 @@ LL | impl OtherTrait for i32 {}
    |
    = note: upstream crates may add a new impl of trait `coherence_cross_crate_trait_decl::SomeTrait` for type `i32` in future versions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.stderr b/tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.stderr
index f2aee798608..ef170101b44 100644
--- a/tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.stderr
+++ b/tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.stderr
@@ -7,6 +7,6 @@ LL |
 LL | impl Trait for (u32, i32) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(TAIT, TAIT)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/type-alias-impl-trait/constrain_inputs_unsound.stderr b/tests/ui/type-alias-impl-trait/constrain_inputs_unsound.stderr
index d5fc46cb1f5..948bd6deacd 100644
--- a/tests/ui/type-alias-impl-trait/constrain_inputs_unsound.stderr
+++ b/tests/ui/type-alias-impl-trait/constrain_inputs_unsound.stderr
@@ -4,6 +4,6 @@ error[E0582]: binding for associated type `Output` references lifetime `'a`, whi
 LL |     type MalformedTy = dyn for<'a> Callable<Gal<&'a ()>, Output = &'a str>;
    |                                                          ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0582`.
diff --git a/tests/ui/type-alias-impl-trait/declared_but_never_defined.stderr b/tests/ui/type-alias-impl-trait/declared_but_never_defined.stderr
index 60bc24320a3..772f487d96a 100644
--- a/tests/ui/type-alias-impl-trait/declared_but_never_defined.stderr
+++ b/tests/ui/type-alias-impl-trait/declared_but_never_defined.stderr
@@ -6,5 +6,5 @@ LL | type Bar = impl std::fmt::Debug;
    |
    = note: `Bar` must be used in combination with a concrete type within the same module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/different_defining_uses.stderr b/tests/ui/type-alias-impl-trait/different_defining_uses.stderr
index a8b4cd7afe8..9e6169b2af7 100644
--- a/tests/ui/type-alias-impl-trait/different_defining_uses.stderr
+++ b/tests/ui/type-alias-impl-trait/different_defining_uses.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     ""
    |     ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-2.stderr b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-2.stderr
index b138f9d5c45..e5cee49cf29 100644
--- a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-2.stderr
+++ b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-2.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |         if { return } {
    |              ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-3.stderr b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-3.stderr
index 8fc2e22848c..0fdcb81f667 100644
--- a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-3.stderr
+++ b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type-3.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     let x: Tait<T> = ();
    |                      ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type.stderr b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type.stderr
index 09dadb0afce..2a77eb4c4ac 100644
--- a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type.stderr
+++ b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     ""
    |     ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type3.stderr b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type3.stderr
index 146a57cbb7e..abf4a0d241b 100644
--- a/tests/ui/type-alias-impl-trait/different_defining_uses_never_type3.stderr
+++ b/tests/ui/type-alias-impl-trait/different_defining_uses_never_type3.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL | fn one() -> Tait { One }
    |                    ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr b/tests/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr
index 0c50a84e894..07ba17ad27b 100644
--- a/tests/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr
+++ b/tests/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     a
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/escaping-bound-var.stderr b/tests/ui/type-alias-impl-trait/escaping-bound-var.stderr
index 8205a60ccdd..7dce067d39c 100644
--- a/tests/ui/type-alias-impl-trait/escaping-bound-var.stderr
+++ b/tests/ui/type-alias-impl-trait/escaping-bound-var.stderr
@@ -4,5 +4,5 @@ error: cannot capture late-bound lifetime in type alias impl trait
 LL | pub type Foo = impl for<'a> Trait<'a, Assoc = impl Test<'a>>;
    |                         -- lifetime defined here        ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/fallback.stderr b/tests/ui/type-alias-impl-trait/fallback.stderr
index e767bfdb08b..5250252a0da 100644
--- a/tests/ui/type-alias-impl-trait/fallback.stderr
+++ b/tests/ui/type-alias-impl-trait/fallback.stderr
@@ -12,6 +12,6 @@ help: consider specifying the generic argument
 LL |     Wrapper::<T>::Second
    |            +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/type-alias-impl-trait/future.stderr b/tests/ui/type-alias-impl-trait/future.stderr
index 7e76c120a25..b20073fcdfc 100644
--- a/tests/ui/type-alias-impl-trait/future.stderr
+++ b/tests/ui/type-alias-impl-trait/future.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `B`
 LL | type FooFuture<B: Bar> = impl Future<Output = ()>;
    |                 +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/generic_different_defining_uses.stderr b/tests/ui/type-alias-impl-trait/generic_different_defining_uses.stderr
index 47ac3346259..72271d158a1 100644
--- a/tests/ui/type-alias-impl-trait/generic_different_defining_uses.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_different_defining_uses.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     std::iter::once(t)
    |     ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
index 3dbfff7453f..d2d6380b65a 100644
--- a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use2.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | type Two<T: std::fmt::Debug, U> = impl Debug;
    |           +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
index 21a5369d9ff..2338dbd522b 100644
--- a/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_duplicate_param_use4.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `U`
 LL | type Two<T, U: std::fmt::Debug> = impl Debug;
    |              +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/hidden_behind_projection_behind_struct_field.stderr b/tests/ui/type-alias-impl-trait/hidden_behind_projection_behind_struct_field.stderr
index 648efd1cbfe..00aedfae463 100644
--- a/tests/ui/type-alias-impl-trait/hidden_behind_projection_behind_struct_field.stderr
+++ b/tests/ui/type-alias-impl-trait/hidden_behind_projection_behind_struct_field.stderr
@@ -15,6 +15,6 @@ note: this item must have the opaque type in its signature in order to be able t
 LL |     fn foo() -> Foo<Bar> {
    |        ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-alias-impl-trait/hidden_type_mismatch.stderr b/tests/ui/type-alias-impl-trait/hidden_type_mismatch.stderr
index 85e8a600ce3..5a6998f4165 100644
--- a/tests/ui/type-alias-impl-trait/hidden_type_mismatch.stderr
+++ b/tests/ui/type-alias-impl-trait/hidden_type_mismatch.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     pub type Tait = impl Copy + From<Bar<()>> + Into<Bar<()>>;
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/higher_kinded_params2.stderr b/tests/ui/type-alias-impl-trait/higher_kinded_params2.stderr
index 39f584dd49c..e037dede2e0 100644
--- a/tests/ui/type-alias-impl-trait/higher_kinded_params2.stderr
+++ b/tests/ui/type-alias-impl-trait/higher_kinded_params2.stderr
@@ -11,5 +11,5 @@ note: this item must mention the opaque type in its signature in order to be abl
 LL |     fn successors(&self, mut f: for<'x> fn(&'x ()) -> <&'x A as B>::C) -> Successors<'_> {
    |        ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr b/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr
index 8cf8fb1d16c..137a4db81b5 100644
--- a/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr
+++ b/tests/ui/type-alias-impl-trait/impl-with-unconstrained-param.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T> X for () {
    |      ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/impl_for_weak_alias.stderr b/tests/ui/type-alias-impl-trait/impl_for_weak_alias.stderr
index c312ee7dece..a13e9eaab3a 100644
--- a/tests/ui/type-alias-impl-trait/impl_for_weak_alias.stderr
+++ b/tests/ui/type-alias-impl-trait/impl_for_weak_alias.stderr
@@ -6,6 +6,6 @@ LL | impl Trait for Alias {}
    |
    = note: a trait object implements `Trait` if and only if `Trait` is one of the trait object's trait bounds
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0321`.
diff --git a/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound.stderr b/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound.stderr
index 1c83105a18a..9840bcef7d1 100644
--- a/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound.stderr
+++ b/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `is_yay`
 LL | fn is_yay<T: Yay>() { }
    |              ^^^ required by this bound in `is_yay`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound2.stderr b/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound2.stderr
index a6440f02c27..2259aa7bb15 100644
--- a/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound2.stderr
+++ b/tests/ui/type-alias-impl-trait/impl_trait_for_tait_bound2.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `is_yay`
 LL | fn is_yay<T: Yay>() { }
    |              ^^^ required by this bound in `is_yay`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/implied_bounds.stderr b/tests/ui/type-alias-impl-trait/implied_bounds.stderr
index 6f11b66634b..64a203fe465 100644
--- a/tests/ui/type-alias-impl-trait/implied_bounds.stderr
+++ b/tests/ui/type-alias-impl-trait/implied_bounds.stderr
@@ -12,5 +12,5 @@ LL |         x
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/implied_bounds_closure.stderr b/tests/ui/type-alias-impl-trait/implied_bounds_closure.stderr
index 151564c3b45..f3f9962f106 100644
--- a/tests/ui/type-alias-impl-trait/implied_bounds_closure.stderr
+++ b/tests/ui/type-alias-impl-trait/implied_bounds_closure.stderr
@@ -7,5 +7,5 @@ LL |     let t = into_impl(x);
 LL |     helper(|_| t)
    |                ^ returning this value requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/implied_bounds_from_types.stderr b/tests/ui/type-alias-impl-trait/implied_bounds_from_types.stderr
index cbc5e607318..5967a946830 100644
--- a/tests/ui/type-alias-impl-trait/implied_bounds_from_types.stderr
+++ b/tests/ui/type-alias-impl-trait/implied_bounds_from_types.stderr
@@ -12,5 +12,5 @@ LL |         x
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
index 81bc64bc32c..ff11aee4026 100644
--- a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
+++ b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL |     type Ty<A: 'static> = impl Sized + 'static;
    |              +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/type-alias-impl-trait/imply_bounds_from_bounds_param.stderr b/tests/ui/type-alias-impl-trait/imply_bounds_from_bounds_param.stderr
index 66e4783157b..9bffa94fda1 100644
--- a/tests/ui/type-alias-impl-trait/imply_bounds_from_bounds_param.stderr
+++ b/tests/ui/type-alias-impl-trait/imply_bounds_from_bounds_param.stderr
@@ -13,6 +13,6 @@ help: to declare that `impl PlusOne` captures `'a`, you can add an explicit `'a`
 LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + 'a {
    |                                             ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr b/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr
index b93ea955c89..f0cf681d8bb 100644
--- a/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr
+++ b/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr
@@ -7,6 +7,6 @@ LL | impl<F> FnOnce<()> for &F {
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
    = note: only traits defined in the current crate can be implemented for a type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/type-alias-impl-trait/incomplete-inference.stderr b/tests/ui/type-alias-impl-trait/incomplete-inference.stderr
index 9a0e71b4eed..3976a43a89c 100644
--- a/tests/ui/type-alias-impl-trait/incomplete-inference.stderr
+++ b/tests/ui/type-alias-impl-trait/incomplete-inference.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     None::<T>
    |         +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-alias-impl-trait/indirect-recursion-issue-112047.stderr b/tests/ui/type-alias-impl-trait/indirect-recursion-issue-112047.stderr
index 80b6aaaf919..11d9cd0af08 100644
--- a/tests/ui/type-alias-impl-trait/indirect-recursion-issue-112047.stderr
+++ b/tests/ui/type-alias-impl-trait/indirect-recursion-issue-112047.stderr
@@ -22,6 +22,6 @@ LL |     fn recur(self) -> Self::Recur {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/type-alias-impl-trait/inference-cycle.stderr b/tests/ui/type-alias-impl-trait/inference-cycle.stderr
index ef7abe58864..fd7488fa260 100644
--- a/tests/ui/type-alias-impl-trait/inference-cycle.stderr
+++ b/tests/ui/type-alias-impl-trait/inference-cycle.stderr
@@ -22,5 +22,5 @@ note: required by a bound in `is_send`
 LL |     fn is_send<T: Send>(_: T) {}
    |                   ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/infinite-cycle-involving-weak.stderr b/tests/ui/type-alias-impl-trait/infinite-cycle-involving-weak.stderr
index 50ae6f38641..d820df472f9 100644
--- a/tests/ui/type-alias-impl-trait/infinite-cycle-involving-weak.stderr
+++ b/tests/ui/type-alias-impl-trait/infinite-cycle-involving-weak.stderr
@@ -4,6 +4,6 @@ error[E0720]: cannot resolve opaque type
 LL | type T = impl Copy;
    |          ^^^^^^^^^ cannot resolve opaque type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0720`.
diff --git a/tests/ui/type-alias-impl-trait/invalid_impl_trait_in_assoc_ty.stderr b/tests/ui/type-alias-impl-trait/invalid_impl_trait_in_assoc_ty.stderr
index 6ec5d13f812..169d8e41d20 100644
--- a/tests/ui/type-alias-impl-trait/invalid_impl_trait_in_assoc_ty.stderr
+++ b/tests/ui/type-alias-impl-trait/invalid_impl_trait_in_assoc_ty.stderr
@@ -17,6 +17,6 @@ note: this item must have the opaque type in its signature in order to be able t
 LL |     fn bar() {
    |        ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-alias-impl-trait/issue-104817.stock.stderr b/tests/ui/type-alias-impl-trait/issue-104817.stock.stderr
index 47bae8bd12b..41c5206d9e8 100644
--- a/tests/ui/type-alias-impl-trait/issue-104817.stock.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-104817.stock.stderr
@@ -6,6 +6,6 @@ LL | impl<T: Send> AnotherTrait for T {}
 LL | impl AnotherTrait for OpaqueType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `OpaqueType`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/type-alias-impl-trait/issue-109054.stderr b/tests/ui/type-alias-impl-trait/issue-109054.stderr
index a611b9fe448..a099b7d8b8a 100644
--- a/tests/ui/type-alias-impl-trait/issue-109054.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-109054.stderr
@@ -7,6 +7,6 @@ LL | type ReturnType<'a> = impl std::future::Future<Output = u32> + 'a;
 LL |         &inner
    |         ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0792`.
diff --git a/tests/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr b/tests/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr
index 4c5fd22556a..4570ce8e41d 100644
--- a/tests/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     fn _unused() -> Opaque { String::new() }
    |                              ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-52843.stderr b/tests/ui/type-alias-impl-trait/issue-52843.stderr
index acd40f9804e..ea4c5297ad5 100644
--- a/tests/ui/type-alias-impl-trait/issue-52843.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-52843.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | type Foo<T: std::default::Default> = impl Default;
    |           +++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/issue-53092.stderr b/tests/ui/type-alias-impl-trait/issue-53092.stderr
index 2109cf8a784..8605a098193 100644
--- a/tests/ui/type-alias-impl-trait/issue-53092.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-53092.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `U`
 LL | type Bug<T, U: std::convert::From<T>> = impl Fn(T) -> U + Copy;
    |              +++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/issue-53096.stderr b/tests/ui/type-alias-impl-trait/issue-53096.stderr
index 0af3a75f853..fba1802efd2 100644
--- a/tests/ui/type-alias-impl-trait/issue-53096.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-53096.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {}
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-53598.stderr b/tests/ui/type-alias-impl-trait/issue-53598.stderr
index f8b8201e2eb..a31aabedba5 100644
--- a/tests/ui/type-alias-impl-trait/issue-53598.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-53598.stderr
@@ -4,5 +4,5 @@ error: type parameter `T` is part of concrete type but not used in parameter lis
 LL |         S::<T>(Default::default())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-57700.stderr b/tests/ui/type-alias-impl-trait/issue-57700.stderr
index 31b6df5d4c3..7efb05f40b0 100644
--- a/tests/ui/type-alias-impl-trait/issue-57700.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-57700.stderr
@@ -4,5 +4,5 @@ error: type parameter `impl Deref<Target = Self>` is part of concrete type but n
 LL |         self
    |         ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-57961.stderr b/tests/ui/type-alias-impl-trait/issue-57961.stderr
index 8d11b488889..314296b5bb3 100644
--- a/tests/ui/type-alias-impl-trait/issue-57961.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-57961.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Foo::Bar`
 LL |     type Bar: Iterator<Item = X>;
    |                        ^^^^^^^^ required by this bound in `Foo::Bar`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/type-alias-impl-trait/issue-60407.stderr b/tests/ui/type-alias-impl-trait/issue-60407.stderr
index fecee27797a..583156b9f7c 100644
--- a/tests/ui/type-alias-impl-trait/issue-60407.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-60407.stderr
@@ -4,5 +4,5 @@ error: fatal error triggered by #[rustc_error]
 LL | fn main() {
    | ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-65384.stderr b/tests/ui/type-alias-impl-trait/issue-65384.stderr
index f6692ae3207..6accd45bad6 100644
--- a/tests/ui/type-alias-impl-trait/issue-65384.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-65384.stderr
@@ -7,6 +7,6 @@ LL | impl MyTrait for () {}
 LL | impl MyTrait for Bar {}
    | ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.stderr b/tests/ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.stderr
index b7af3f06d0d..aa7bcbf6a02 100644
--- a/tests/ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.stderr
@@ -14,6 +14,6 @@ help: consider introducing lifetime `'a` here
 LL | type Return<'a, A> = impl WithAssoc<A, AssocType = impl SomeTrait + 'a>;
    |             +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0261`.
diff --git a/tests/ui/type-alias-impl-trait/issue-70121.stderr b/tests/ui/type-alias-impl-trait/issue-70121.stderr
index 30c3ddd8659..d6ab26e30da 100644
--- a/tests/ui/type-alias-impl-trait/issue-70121.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-70121.stderr
@@ -11,5 +11,5 @@ note: this item must mention the opaque type in its signature in order to be abl
 LL | pub fn kazusa<'a>() -> <&'a () as Tr>::Item {
    |        ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-74244.stderr b/tests/ui/type-alias-impl-trait/issue-74244.stderr
index ff6bacd277e..f5ca56baccc 100644
--- a/tests/ui/type-alias-impl-trait/issue-74244.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-74244.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<T> Allocator for DefaultAllocator {
    |      ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/issue-74280.stderr b/tests/ui/type-alias-impl-trait/issue-74280.stderr
index 66886db6eb9..c09efbe4e13 100644
--- a/tests/ui/type-alias-impl-trait/issue-74280.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-74280.stderr
@@ -7,6 +7,6 @@ LL |     let y = || -> Test { () };
 LL |     7
    |     ^ expected `()`, found integer
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-alias-impl-trait/issue-77179.stderr b/tests/ui/type-alias-impl-trait/issue-77179.stderr
index 053546e4b92..68dd6570d00 100644
--- a/tests/ui/type-alias-impl-trait/issue-77179.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-77179.stderr
@@ -7,6 +7,6 @@ LL | fn test() -> Pointer<_> {
    |              |       not allowed in type signatures
    |              help: replace with the correct return type: `Pointer<i32>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/type-alias-impl-trait/issue-84660-unsoundness.stderr b/tests/ui/type-alias-impl-trait/issue-84660-unsoundness.stderr
index 6a75e1bd2c0..461da20f37b 100644
--- a/tests/ui/type-alias-impl-trait/issue-84660-unsoundness.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-84660-unsoundness.stderr
@@ -7,6 +7,6 @@ LL | impl<In, Out> Trait<Bar, In> for Out {
 LL | impl<In, Out> Trait<(), In> for Out {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/type-alias-impl-trait/issue-89686.stderr b/tests/ui/type-alias-impl-trait/issue-89686.stderr
index b636ada8b75..91d71339a08 100644
--- a/tests/ui/type-alias-impl-trait/issue-89686.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-89686.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `T`
 LL | type G<'a, T: Trait> = impl Future<Output = ()>;
    |             +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/issue-90400-1.stderr b/tests/ui/type-alias-impl-trait/issue-90400-1.stderr
index ead28769f06..bc233a53214 100644
--- a/tests/ui/type-alias-impl-trait/issue-90400-1.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-90400-1.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `B`
 LL |     type FooFn<B: Bar> = impl FnOnce();
    |                 +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/issue-90400-2.stderr b/tests/ui/type-alias-impl-trait/issue-90400-2.stderr
index 0c45046f5f5..37abb3fe021 100644
--- a/tests/ui/type-alias-impl-trait/issue-90400-2.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-90400-2.stderr
@@ -16,6 +16,6 @@ help: consider restricting type parameter `B`
 LL |     type FooFn<B: Bar> = impl Baz;
    |                 +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/issue-94429.stderr b/tests/ui/type-alias-impl-trait/issue-94429.stderr
index 360ecfa61bf..5d081e6b1ef 100644
--- a/tests/ui/type-alias-impl-trait/issue-94429.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-94429.stderr
@@ -4,6 +4,6 @@ error[E0271]: type mismatch resolving `<{coroutine@$DIR/issue-94429.rs:17:9: 17:
 LL |     fn run(&mut self) -> Self::Coro {
    |                          ^^^^^^^^^^ expected integer, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/type-alias-impl-trait/issue-96572-unconstrained-mismatch.stderr b/tests/ui/type-alias-impl-trait/issue-96572-unconstrained-mismatch.stderr
index 728244a1844..4f4ca1041d7 100644
--- a/tests/ui/type-alias-impl-trait/issue-96572-unconstrained-mismatch.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-96572-unconstrained-mismatch.stderr
@@ -10,6 +10,6 @@ LL |         Some((a, b, c)) => (),
    = note: expected tuple `(u32, u32)`
               found tuple `(_, _, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-alias-impl-trait/issue-98604.stderr b/tests/ui/type-alias-impl-trait/issue-98604.stderr
index af758d8099f..2390b725356 100644
--- a/tests/ui/type-alias-impl-trait/issue-98604.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-98604.stderr
@@ -6,6 +6,6 @@ LL |     Box::new(test) as AsyncFnPtr;
    |
    = note: required for the cast from `Box<fn() -> impl Future<Output = ()> {test}>` to `Box<(dyn Fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/type-alias-impl-trait/issue-98608.stderr b/tests/ui/type-alias-impl-trait/issue-98608.stderr
index 9b651008371..d5c56636f66 100644
--- a/tests/ui/type-alias-impl-trait/issue-98608.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-98608.stderr
@@ -11,6 +11,6 @@ LL |     let b: Box<dyn Fn() -> Box<u8>> = Box::new(hi);
            found opaque type `impl Sized`
    = note: required for the cast from `Box<fn() -> impl Sized {hi}>` to `Box<dyn Fn() -> Box<u8>>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0271`.
diff --git a/tests/ui/type-alias-impl-trait/missing_lifetime_bound.stderr b/tests/ui/type-alias-impl-trait/missing_lifetime_bound.stderr
index 6bcae6e5316..03cc943d509 100644
--- a/tests/ui/type-alias-impl-trait/missing_lifetime_bound.stderr
+++ b/tests/ui/type-alias-impl-trait/missing_lifetime_bound.stderr
@@ -9,6 +9,6 @@ LL | fn defining<'a, T>(x: &'a i32) -> Opaque<T> { x }
    |             |
    |             hidden type `&'a i32` captures the lifetime `'a` as defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/type-alias-impl-trait/multi-error.stderr b/tests/ui/type-alias-impl-trait/multi-error.stderr
index b2de2effea6..b0e6d13b0e1 100644
--- a/tests/ui/type-alias-impl-trait/multi-error.stderr
+++ b/tests/ui/type-alias-impl-trait/multi-error.stderr
@@ -10,6 +10,6 @@ note: for this opaque type
 LL |     type Bar<T> = impl Sized;
    |                   ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0792`.
diff --git a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr
index 27811700912..b050b08a8e2 100644
--- a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr
+++ b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr
@@ -7,5 +7,5 @@ LL |     (42_i64, 60)
    |     expected `i64`, got `i32`
    |     this expression supplies two conflicting concrete types for the same opaque type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr
index 81e603e2355..552cf3fda30 100644
--- a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr
+++ b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr
@@ -7,5 +7,5 @@ LL |     (i, i)
    |     expected `&'a i32`, got `&'b i32`
    |     this expression supplies two conflicting concrete types for the same opaque type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn.stderr b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn.stderr
index 66a6b0bbf74..b5f38074632 100644
--- a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn.stderr
+++ b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn.stderr
@@ -10,6 +10,6 @@ help: consider introducing a `where` clause, but there might be an alternative b
 LL | fn f<A, B: 'static>(a: &'static A, b: B) -> (X<A, B>, X<B, A>) where &'static B: From<&A> {
    |                                                                ++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr
index 0f752212ac9..c7a4b2115bf 100644
--- a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr
+++ b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr
@@ -7,5 +7,5 @@ LL |     (a.clone(), a)
    |     expected `A`, got `B`
    |     this expression supplies two conflicting concrete types for the same opaque type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn3.stderr b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn3.stderr
index bbe709dccab..c3128ea6f5e 100644
--- a/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn3.stderr
+++ b/tests/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn3.stderr
@@ -13,6 +13,6 @@ LL |     (a, b)
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-alias-impl-trait/mututally-recursive-overflow.stderr b/tests/ui/type-alias-impl-trait/mututally-recursive-overflow.stderr
index 49c59f7eb37..cf6e42bc722 100644
--- a/tests/ui/type-alias-impl-trait/mututally-recursive-overflow.stderr
+++ b/tests/ui/type-alias-impl-trait/mututally-recursive-overflow.stderr
@@ -1,5 +1,5 @@
 error[E0275]: overflow evaluating the requirement `<() as B>::Assoc == _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/type-alias-impl-trait/nested-tait-inference.stderr b/tests/ui/type-alias-impl-trait/nested-tait-inference.stderr
index 62db019ed6a..172ecded7a2 100644
--- a/tests/ui/type-alias-impl-trait/nested-tait-inference.stderr
+++ b/tests/ui/type-alias-impl-trait/nested-tait-inference.stderr
@@ -9,6 +9,6 @@ LL |     ()
    |
    = help: the trait `Foo<()>` is implemented for `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/nested-tait-inference2.stderr b/tests/ui/type-alias-impl-trait/nested-tait-inference2.stderr
index dccf84362f0..c549ca5b2ce 100644
--- a/tests/ui/type-alias-impl-trait/nested-tait-inference2.stderr
+++ b/tests/ui/type-alias-impl-trait/nested-tait-inference2.stderr
@@ -11,6 +11,6 @@ LL |     ()
              <() as Foo<u32>>
              <() as Foo<()>>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/nested-tait-inference3.stderr b/tests/ui/type-alias-impl-trait/nested-tait-inference3.stderr
index b1d947a9ccf..ce5d3037053 100644
--- a/tests/ui/type-alias-impl-trait/nested-tait-inference3.stderr
+++ b/tests/ui/type-alias-impl-trait/nested-tait-inference3.stderr
@@ -6,5 +6,5 @@ LL | type FooX = impl Debug;
    |
    = note: `FooX` must be used in combination with a concrete type within the same module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/nested.stderr b/tests/ui/type-alias-impl-trait/nested.stderr
index 732af5c0b56..a19d4c4eb71 100644
--- a/tests/ui/type-alias-impl-trait/nested.stderr
+++ b/tests/ui/type-alias-impl-trait/nested.stderr
@@ -7,6 +7,6 @@ LL |     println!("{:?}", bar());
    = help: the trait `Debug` is not implemented for `Bar`
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/nested_type_alias_impl_trait.stderr b/tests/ui/type-alias-impl-trait/nested_type_alias_impl_trait.stderr
index fa6ecf68d28..3e67a162f0f 100644
--- a/tests/ui/type-alias-impl-trait/nested_type_alias_impl_trait.stderr
+++ b/tests/ui/type-alias-impl-trait/nested_type_alias_impl_trait.stderr
@@ -15,5 +15,5 @@ note: opaque type being used as hidden type
 LL |     pub type Foo = impl Debug;
    |                    ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr b/tests/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr
index f3e8ae9c7db..fabc80c0a4f 100644
--- a/tests/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr
+++ b/tests/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr
@@ -6,5 +6,5 @@ LL |     pub type Foo = impl Copy;
    |
    = note: `Foo` must be used in combination with a concrete type within the same module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/non-defining-method.stderr b/tests/ui/type-alias-impl-trait/non-defining-method.stderr
index ed5590f9d71..2ba4c90a1c4 100644
--- a/tests/ui/type-alias-impl-trait/non-defining-method.stderr
+++ b/tests/ui/type-alias-impl-trait/non-defining-method.stderr
@@ -10,6 +10,6 @@ note: for this opaque type
 LL |     type Bar<T> = impl Sized;
    |                   ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0792`.
diff --git a/tests/ui/type-alias-impl-trait/not-matching-trait-refs-isnt-defining.stderr b/tests/ui/type-alias-impl-trait/not-matching-trait-refs-isnt-defining.stderr
index a621bb519cd..d4528fb76fe 100644
--- a/tests/ui/type-alias-impl-trait/not-matching-trait-refs-isnt-defining.stderr
+++ b/tests/ui/type-alias-impl-trait/not-matching-trait-refs-isnt-defining.stderr
@@ -17,6 +17,6 @@ note: this item must have the opaque type in its signature in order to be able t
 LL |     fn test() -> <() as Foo<NoOpaques>>::Assoc {
    |        ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-alias-impl-trait/not_well_formed.stderr b/tests/ui/type-alias-impl-trait/not_well_formed.stderr
index b267e6a7544..dbd80ffa4f6 100644
--- a/tests/ui/type-alias-impl-trait/not_well_formed.stderr
+++ b/tests/ui/type-alias-impl-trait/not_well_formed.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `V`
 LL | type Foo<V: TraitWithAssoc> = impl Trait<V::Assoc>;
    |           ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/ui/type-alias-impl-trait/recursive-fn-tait.stderr b/tests/ui/type-alias-impl-trait/recursive-fn-tait.stderr
index b2898a21190..e8925b9b489 100644
--- a/tests/ui/type-alias-impl-trait/recursive-fn-tait.stderr
+++ b/tests/ui/type-alias-impl-trait/recursive-fn-tait.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |     |_: usize |loop {}
    |     ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn-2.stderr b/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn-2.stderr
index 7481557fcba..eec35548c55 100644
--- a/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn-2.stderr
+++ b/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn-2.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL | fn foo() -> Op { &"hello world" }
    |                  ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn.stderr b/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn.stderr
index e4209643b7a..05825e68625 100644
--- a/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn.stderr
+++ b/tests/ui/type-alias-impl-trait/recursive-tait-conflicting-defn.stderr
@@ -10,5 +10,5 @@ note: previous use here
 LL |   A
    |   ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/self-referential-2.stderr b/tests/ui/type-alias-impl-trait/self-referential-2.stderr
index c2cf70687fd..ab57812ba9b 100644
--- a/tests/ui/type-alias-impl-trait/self-referential-2.stderr
+++ b/tests/ui/type-alias-impl-trait/self-referential-2.stderr
@@ -9,6 +9,6 @@ LL |     42_i32
    = help: the trait `PartialEq<Foo>` is not implemented for `i32`
    = help: the trait `PartialEq` is implemented for `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/self-referential-3.stderr b/tests/ui/type-alias-impl-trait/self-referential-3.stderr
index 4155a114b4f..15ebcdafca6 100644
--- a/tests/ui/type-alias-impl-trait/self-referential-3.stderr
+++ b/tests/ui/type-alias-impl-trait/self-referential-3.stderr
@@ -10,6 +10,6 @@ LL |     i
    = help: the trait `PartialEq<Bar<'a, 'b>>` is not implemented for `&i32`
    = help: the trait `PartialEq` is implemented for `i32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/structural-match-no-leak.stderr b/tests/ui/type-alias-impl-trait/structural-match-no-leak.stderr
index dbc183f54f4..b1ccd5cc402 100644
--- a/tests/ui/type-alias-impl-trait/structural-match-no-leak.stderr
+++ b/tests/ui/type-alias-impl-trait/structural-match-no-leak.stderr
@@ -4,5 +4,5 @@ error: `Bar` cannot be used in patterns
 LL |         LEAK_FREE => (),
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/structural-match.stderr b/tests/ui/type-alias-impl-trait/structural-match.stderr
index 61287f26806..b0415db0e55 100644
--- a/tests/ui/type-alias-impl-trait/structural-match.stderr
+++ b/tests/ui/type-alias-impl-trait/structural-match.stderr
@@ -4,5 +4,5 @@ error: `Foo` cannot be used in patterns
 LL |         VALUE => (),
    |         ^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-fn-type.stderr b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-fn-type.stderr
index e57c59d6165..5641ff30164 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-fn-type.stderr
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-fn-type.stderr
@@ -4,6 +4,6 @@ error[E0562]: `impl Trait` only allowed in function and inherent method argument
 LL | type Foo = fn() -> impl Send;
    |                    ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0562`.
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-unconstrained-lifetime.stderr b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-unconstrained-lifetime.stderr
index 8cdce2f8e81..cff2695304a 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-unconstrained-lifetime.stderr
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-unconstrained-lifetime.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a, I: Iterator<Item = i32>> Trait for (i32, I) {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr
index a770eeac39b..3d43fbe0dbc 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr
@@ -6,5 +6,5 @@ LL | type Foo = impl Fn() -> Foo;
    |
    = note: `Foo` must be used in combination with a concrete type within the same module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr
index 3f3699ce532..e2dc887989b 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr
@@ -6,5 +6,5 @@ LL | type Foo = impl Bar<Foo, Item = Foo>;
    |
    = note: `Foo` must be used in combination with a concrete type within the same module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/unconstrained-due-to-bad-pattern.stderr b/tests/ui/type-alias-impl-trait/unconstrained-due-to-bad-pattern.stderr
index 6cc5b7a8a0a..6d9c8eabfad 100644
--- a/tests/ui/type-alias-impl-trait/unconstrained-due-to-bad-pattern.stderr
+++ b/tests/ui/type-alias-impl-trait/unconstrained-due-to-bad-pattern.stderr
@@ -12,6 +12,6 @@ LL +             _ => todo!(),
 LL +         }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/type-alias-impl-trait/unconstrained-impl-param.stderr b/tests/ui/type-alias-impl-trait/unconstrained-impl-param.stderr
index 65139307f8e..6206f169c5b 100644
--- a/tests/ui/type-alias-impl-trait/unconstrained-impl-param.stderr
+++ b/tests/ui/type-alias-impl-trait/unconstrained-impl-param.stderr
@@ -4,6 +4,6 @@ error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait,
 LL | impl<'a> Trait for Opaque<&'a str> {
    |      ^^ unconstrained lifetime parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/type-alias-impl-trait/under-binder.stderr b/tests/ui/type-alias-impl-trait/under-binder.stderr
index 82c4ec97335..f4a121ce440 100644
--- a/tests/ui/type-alias-impl-trait/under-binder.stderr
+++ b/tests/ui/type-alias-impl-trait/under-binder.stderr
@@ -7,6 +7,6 @@ LL | type Opaque<'a> = impl Sized + 'a;
 LL |     f
    |     ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0792`.
diff --git a/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr b/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr
index 103636b6cdd..e4de9245951 100644
--- a/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr
+++ b/tests/ui/type-alias-impl-trait/underconstrained_generic.stderr
@@ -16,6 +16,6 @@ help: consider restricting type parameter `T`
 LL | type Converter<T: Trait> = impl ProofForConversion<T>;
    |                 +++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/underconstrained_lifetime.stderr b/tests/ui/type-alias-impl-trait/underconstrained_lifetime.stderr
index 12d85a49d01..34b50fb1f05 100644
--- a/tests/ui/type-alias-impl-trait/underconstrained_lifetime.stderr
+++ b/tests/ui/type-alias-impl-trait/underconstrained_lifetime.stderr
@@ -15,6 +15,6 @@ note: but the referenced data is only valid for the lifetime `'a` as defined her
 LL | type Converter<'a, 'b> = impl ProofForConversion<'a, 'b>;
    |                ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0491`.
diff --git a/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr b/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr
index e0005489d1e..47bea7bbe60 100644
--- a/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-check-fn-def.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `B`
 LL | type FooFn<B: Bar> = impl FnOnce(B);
    |             +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr b/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
index 2858afcd46f..dcc4b8021ea 100644
--- a/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
@@ -17,6 +17,6 @@ help: consider adding an explicit lifetime bound
 LL |     type InnerOpaque<T: 'static> = impl Sized;
    |                       +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr b/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
index 285e4f18ca3..121664bd956 100644
--- a/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL |     fn test<T: 'static>() {
    |              +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/type-alias-impl-trait/wf_check_closures.stderr b/tests/ui/type-alias-impl-trait/wf_check_closures.stderr
index 58ae8617b9b..09a42f73490 100644
--- a/tests/ui/type-alias-impl-trait/wf_check_closures.stderr
+++ b/tests/ui/type-alias-impl-trait/wf_check_closures.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `B`
 LL | type FooFn<B: Bar> = impl FnOnce();
    |             +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type-alias/issue-62263-self-in-atb.stderr b/tests/ui/type-alias/issue-62263-self-in-atb.stderr
index c20074dc27c..18c8bc1a1b3 100644
--- a/tests/ui/type-alias/issue-62263-self-in-atb.stderr
+++ b/tests/ui/type-alias/issue-62263-self-in-atb.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: `Self` is only available in impls, traits, and
 LL | pub type Alias = dyn Trait<A = Self::A>;
    |                                ^^^^ `Self` is only available in impls, traits, and type definitions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/type-alias/issue-62305-self-assoc-ty.stderr b/tests/ui/type-alias/issue-62305-self-assoc-ty.stderr
index f3da50df926..a35e644d3aa 100644
--- a/tests/ui/type-alias/issue-62305-self-assoc-ty.stderr
+++ b/tests/ui/type-alias/issue-62305-self-assoc-ty.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: `Self` is only available in impls, traits, and
 LL | type Alias = Self::Target;
    |              ^^^^ `Self` is only available in impls, traits, and type definitions
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/type-alias/issue-62364-self-ty-arg.stderr b/tests/ui/type-alias/issue-62364-self-ty-arg.stderr
index 7e15e42e3cc..26d93dcc272 100644
--- a/tests/ui/type-alias/issue-62364-self-ty-arg.stderr
+++ b/tests/ui/type-alias/issue-62364-self-ty-arg.stderr
@@ -6,6 +6,6 @@ LL | type Alias<'a> = Struct<&'a Self>;
    |      |
    |      `Self` not allowed in a type alias
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0411`.
diff --git a/tests/ui/type-inference/issue-30225.stderr b/tests/ui/type-inference/issue-30225.stderr
index 72c33d16cab..cd2d9e2bea8 100644
--- a/tests/ui/type-inference/issue-30225.stderr
+++ b/tests/ui/type-inference/issue-30225.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     u = v; // mark $0 and $1 in a subtype relationship
    |         ^ expected `A`, found `B`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-inference/or_else-multiple-type-params.stderr b/tests/ui/type-inference/or_else-multiple-type-params.stderr
index 6ac63a91ee9..d1bbe308ed3 100644
--- a/tests/ui/type-inference/or_else-multiple-type-params.stderr
+++ b/tests/ui/type-inference/or_else-multiple-type-params.stderr
@@ -9,6 +9,6 @@ help: try giving this closure an explicit return type
 LL |         .or_else(|err| -> Result<Child, F> {
    |                        +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-inference/sort_by_key.stderr b/tests/ui/type-inference/sort_by_key.stderr
index 81af024b3fb..3d2e0250dd2 100644
--- a/tests/ui/type-inference/sort_by_key.stderr
+++ b/tests/ui/type-inference/sort_by_key.stderr
@@ -14,6 +14,6 @@ help: consider specifying the generic argument
 LL |     lst.sort_by_key(|&(v, _)| v.iter().sum::<S>());
    |                                           +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/type-inference/unbounded-associated-type.stderr b/tests/ui/type-inference/unbounded-associated-type.stderr
index e0fecc72f30..c9dfa0bf587 100644
--- a/tests/ui/type-inference/unbounded-associated-type.stderr
+++ b/tests/ui/type-inference/unbounded-associated-type.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     S(std::marker::PhantomData::<T>).foo();
    |                               +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr b/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
index 209abfe5cba..dc0bea58a70 100644
--- a/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
+++ b/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic arguments
 LL |     foo::<T, U>();
    |        ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-inference/unbounded-type-param-in-fn.stderr b/tests/ui/type-inference/unbounded-type-param-in-fn.stderr
index d92892eeb84..31e6e805e6c 100644
--- a/tests/ui/type-inference/unbounded-type-param-in-fn.stderr
+++ b/tests/ui/type-inference/unbounded-type-param-in-fn.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     foo::<T>();
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type/ascription/issue-34255-1.stderr b/tests/ui/type/ascription/issue-34255-1.stderr
index 254d36cb947..6cb42fad614 100644
--- a/tests/ui/type/ascription/issue-34255-1.stderr
+++ b/tests/ui/type/ascription/issue-34255-1.stderr
@@ -14,5 +14,5 @@ LL |         input_cells: Vec::new()
 LL ~     } }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/ascription/issue-47666.stderr b/tests/ui/type/ascription/issue-47666.stderr
index 74d85a75c85..562ce53052b 100644
--- a/tests/ui/type/ascription/issue-47666.stderr
+++ b/tests/ui/type/ascription/issue-47666.stderr
@@ -6,5 +6,5 @@ LL |     let _ = Option:Some(vec![0, 1]);
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/ascription/issue-54516.stderr b/tests/ui/type/ascription/issue-54516.stderr
index a1371432f5a..2c567a1a0ff 100644
--- a/tests/ui/type/ascription/issue-54516.stderr
+++ b/tests/ui/type/ascription/issue-54516.stderr
@@ -6,5 +6,5 @@ LL |     println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/ascription/issue-60933.stderr b/tests/ui/type/ascription/issue-60933.stderr
index 0ec527ff5a9..cd184ceba33 100644
--- a/tests/ui/type/ascription/issue-60933.stderr
+++ b/tests/ui/type/ascription/issue-60933.stderr
@@ -6,5 +6,5 @@ LL |     let _: usize = std::mem:size_of::<u32>();
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/closure-with-wrong-borrows.stderr b/tests/ui/type/closure-with-wrong-borrows.stderr
index 7370bc76467..65e11ec52fc 100644
--- a/tests/ui/type/closure-with-wrong-borrows.stderr
+++ b/tests/ui/type/closure-with-wrong-borrows.stderr
@@ -14,6 +14,6 @@ note: function defined here
 LL | fn f(inner: fn(&str, &S)) {
    |    ^ -------------------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/issue-101866.stderr b/tests/ui/type/issue-101866.stderr
index fe99821198e..6f4b380b4e7 100644
--- a/tests/ui/type/issue-101866.stderr
+++ b/tests/ui/type/issue-101866.stderr
@@ -13,6 +13,6 @@ LL -     TraitA::<i32>::func();
 LL +     <StructA as TraitA<i32>>::func();
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/type/issue-58355.stderr b/tests/ui/type/issue-58355.stderr
index 67078bcfe89..b6056f0fd65 100644
--- a/tests/ui/type/issue-58355.stderr
+++ b/tests/ui/type/issue-58355.stderr
@@ -8,6 +8,6 @@ LL |     x = Some(Box::new(callback));
    = note: required because it appears within the type `fn() -> dyn ToString`
    = note: required for the cast from `Box<fn() -> dyn ToString>` to `Box<dyn Fn() -> (dyn ToString + 'static)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/type/issue-91268.stderr b/tests/ui/type/issue-91268.stderr
index a3619d863e2..395559442d1 100644
--- a/tests/ui/type/issue-91268.stderr
+++ b/tests/ui/type/issue-91268.stderr
@@ -8,5 +8,5 @@ LL |     0: u8(ţ
    |          |
    |          unclosed delimiter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/missing-let-in-binding-2.stderr b/tests/ui/type/missing-let-in-binding-2.stderr
index 2e10125943e..abf24763abc 100644
--- a/tests/ui/type/missing-let-in-binding-2.stderr
+++ b/tests/ui/type/missing-let-in-binding-2.stderr
@@ -9,5 +9,5 @@ help: you might have meant to introduce a new binding
 LL |     let _v: Vec<i32> = vec![1, 2, 3];
    |     +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/missing-let-in-binding-3.stderr b/tests/ui/type/missing-let-in-binding-3.stderr
index ca828ce37eb..b01323b4e66 100644
--- a/tests/ui/type/missing-let-in-binding-3.stderr
+++ b/tests/ui/type/missing-let-in-binding-3.stderr
@@ -6,5 +6,5 @@ LL | struct A {
 LL |     : :u8,
    |     ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/missing-let-in-binding-4.stderr b/tests/ui/type/missing-let-in-binding-4.stderr
index e6f173a6658..258eab5b91f 100644
--- a/tests/ui/type/missing-let-in-binding-4.stderr
+++ b/tests/ui/type/missing-let-in-binding-4.stderr
@@ -6,5 +6,5 @@ LL | struct A {
 LL |     : u8 =,
    |     ^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/missing-let-in-binding.stderr b/tests/ui/type/missing-let-in-binding.stderr
index fc094e8cbad..a9d766e4c3c 100644
--- a/tests/ui/type/missing-let-in-binding.stderr
+++ b/tests/ui/type/missing-let-in-binding.stderr
@@ -10,5 +10,5 @@ help: you might have meant to introduce a new binding
 LL |     let _foo: i32 = 4;
    |     +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/type-annotation-needed.stderr b/tests/ui/type/type-annotation-needed.stderr
index 87bba3166be..521d25537f3 100644
--- a/tests/ui/type/type-annotation-needed.stderr
+++ b/tests/ui/type/type-annotation-needed.stderr
@@ -15,6 +15,6 @@ help: consider specifying the generic argument
 LL |     foo::<T>(42);
    |        +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/type/type-ascription-with-fn-call.stderr b/tests/ui/type/type-ascription-with-fn-call.stderr
index e3afa497ac2..2ae5873c824 100644
--- a/tests/ui/type/type-ascription-with-fn-call.stderr
+++ b/tests/ui/type/type-ascription-with-fn-call.stderr
@@ -6,5 +6,5 @@ LL |     f()  :
    |
    = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/type-check/cannot_infer_local_or_array.stderr b/tests/ui/type/type-check/cannot_infer_local_or_array.stderr
index e823bad2668..dafbab8278d 100644
--- a/tests/ui/type/type-check/cannot_infer_local_or_array.stderr
+++ b/tests/ui/type/type-check/cannot_infer_local_or_array.stderr
@@ -9,6 +9,6 @@ help: consider giving `x` an explicit type, where the placeholders `_` are speci
 LL |     let x: [_; 0] = [];
    |          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type/type-check/cannot_infer_local_or_vec.stderr b/tests/ui/type/type-check/cannot_infer_local_or_vec.stderr
index 7be00341d10..fa90240d34e 100644
--- a/tests/ui/type/type-check/cannot_infer_local_or_vec.stderr
+++ b/tests/ui/type/type-check/cannot_infer_local_or_vec.stderr
@@ -9,6 +9,6 @@ help: consider giving `x` an explicit type, where the placeholders `_` are speci
 LL |     let x: Vec<_> = vec![];
    |          ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type/type-check/cannot_infer_local_or_vec_in_tuples.stderr b/tests/ui/type/type-check/cannot_infer_local_or_vec_in_tuples.stderr
index 1fa253052e6..5f389bee710 100644
--- a/tests/ui/type/type-check/cannot_infer_local_or_vec_in_tuples.stderr
+++ b/tests/ui/type/type-check/cannot_infer_local_or_vec_in_tuples.stderr
@@ -9,6 +9,6 @@ help: consider giving this pattern a type, where the placeholders `_` are specif
 LL |     let (x, ): (Vec<_>,) = (vec![], );
    |              +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type/type-check/issue-116967-cannot-coerce-returned-result.stderr b/tests/ui/type/type-check/issue-116967-cannot-coerce-returned-result.stderr
index 447b22a152d..3a8d9c71968 100644
--- a/tests/ui/type/type-check/issue-116967-cannot-coerce-returned-result.stderr
+++ b/tests/ui/type/type-check/issue-116967-cannot-coerce-returned-result.stderr
@@ -10,6 +10,6 @@ LL |     out
    = note: expected enum `Result<String, _>`
               found enum `Result<(), _>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-check/issue-22897.stderr b/tests/ui/type/type-check/issue-22897.stderr
index fae7b79269b..e3e8deb3046 100644
--- a/tests/ui/type/type-check/issue-22897.stderr
+++ b/tests/ui/type/type-check/issue-22897.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL |     [];
    |     ^^ cannot infer type for array `[_; 0]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type/type-check/issue-40294.stderr b/tests/ui/type/type-check/issue-40294.stderr
index d15fd23418b..c6c1d689324 100644
--- a/tests/ui/type/type-check/issue-40294.stderr
+++ b/tests/ui/type/type-check/issue-40294.stderr
@@ -12,6 +12,6 @@ LL |     where &'a T : Foo,
 LL |           &'b T : Foo
    |                   ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.
diff --git a/tests/ui/type/type-check/issue-41314.stderr b/tests/ui/type/type-check/issue-41314.stderr
index 4a9bf610647..2a089029b0a 100644
--- a/tests/ui/type/type-check/issue-41314.stderr
+++ b/tests/ui/type/type-check/issue-41314.stderr
@@ -9,6 +9,6 @@ help: use the tuple variant pattern syntax instead
 LL |         X::Y(number) => {}
    |             ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0769`.
diff --git a/tests/ui/type/type-check/issue-67273-assignment-match-prior-arm-bool-expected-unit.stderr b/tests/ui/type/type-check/issue-67273-assignment-match-prior-arm-bool-expected-unit.stderr
index a431fe89c23..229729a9ba6 100644
--- a/tests/ui/type/type-check/issue-67273-assignment-match-prior-arm-bool-expected-unit.stderr
+++ b/tests/ui/type/type-check/issue-67273-assignment-match-prior-arm-bool-expected-unit.stderr
@@ -17,6 +17,6 @@ LL | |         _ => (),
 LL | |     }
    | |_____- `match` arms have incompatible types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-check/issue-88577-check-fn-with-more-than-65535-arguments.stderr b/tests/ui/type/type-check/issue-88577-check-fn-with-more-than-65535-arguments.stderr
index 847bc517ea3..1ef02321e15 100644
--- a/tests/ui/type/type-check/issue-88577-check-fn-with-more-than-65535-arguments.stderr
+++ b/tests/ui/type/type-check/issue-88577-check-fn-with-more-than-65535-arguments.stderr
@@ -9,5 +9,5 @@ LL | many_args!{[_]########## ######}
    |
    = note: this error originates in the macro `many_args` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type/type-check/point-at-inference-3.stderr b/tests/ui/type/type-check/point-at-inference-3.stderr
index 23876481236..663799e9f86 100644
--- a/tests/ui/type/type-check/point-at-inference-3.stderr
+++ b/tests/ui/type/type-check/point-at-inference-3.stderr
@@ -18,6 +18,6 @@ help: change the type of the numeric literal from `u32` to `i32`
 LL |     v.push(1i32);
    |             ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-check/point-at-inference-issue-116155.stderr b/tests/ui/type/type-check/point-at-inference-issue-116155.stderr
index c8c01603cb8..703694abe59 100644
--- a/tests/ui/type/type-check/point-at-inference-issue-116155.stderr
+++ b/tests/ui/type/type-check/point-at-inference-issue-116155.stderr
@@ -13,6 +13,6 @@ LL |     let _: S<usize> = s;
    = note: expected struct `S<usize>`
               found struct `S<bool>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-check/point-at-inference.stderr b/tests/ui/type/type-check/point-at-inference.stderr
index 5fc94d4d1b6..b5b0353eb18 100644
--- a/tests/ui/type/type-check/point-at-inference.stderr
+++ b/tests/ui/type/type-check/point-at-inference.stderr
@@ -23,6 +23,6 @@ help: consider dereferencing the borrow
 LL |         foo.push(*i);
    |                  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-dependent-def-issue-49241.stderr b/tests/ui/type/type-dependent-def-issue-49241.stderr
index 64c7687f7a8..15d47cca3d2 100644
--- a/tests/ui/type/type-dependent-def-issue-49241.stderr
+++ b/tests/ui/type/type-dependent-def-issue-49241.stderr
@@ -6,6 +6,6 @@ LL |     const l: usize = v.count();
    |     |
    |     help: consider using `let` instead of `const`: `let l`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0435`.
diff --git a/tests/ui/type/type-error-break-tail.stderr b/tests/ui/type/type-error-break-tail.stderr
index 9a02bc28752..5ef522fee2a 100644
--- a/tests/ui/type/type-error-break-tail.stderr
+++ b/tests/ui/type/type-error-break-tail.stderr
@@ -13,6 +13,6 @@ help: give it a value of the expected type
 LL |         if false { break 42; }
    |                          ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-parameter-defaults-referencing-Self.stderr b/tests/ui/type/type-parameter-defaults-referencing-Self.stderr
index 67a4745b399..16d08b26722 100644
--- a/tests/ui/type/type-parameter-defaults-referencing-Self.stderr
+++ b/tests/ui/type/type-parameter-defaults-referencing-Self.stderr
@@ -9,6 +9,6 @@ LL | fn foo(x: &dyn Foo) { }
    |
    = note: because of the default `Self` reference, type parameters must be specified on object types
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0393`.
diff --git a/tests/ui/type/type-parameter-names.stderr b/tests/ui/type/type-parameter-names.stderr
index f0ca8afca4e..8e3e2388c6c 100644
--- a/tests/ui/type/type-parameter-names.stderr
+++ b/tests/ui/type/type-parameter-names.stderr
@@ -14,6 +14,6 @@ LL |     x
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-params-in-different-spaces-1.stderr b/tests/ui/type/type-params-in-different-spaces-1.stderr
index 7529f25bd8e..1d0e097fdc3 100644
--- a/tests/ui/type/type-params-in-different-spaces-1.stderr
+++ b/tests/ui/type/type-params-in-different-spaces-1.stderr
@@ -15,6 +15,6 @@ LL |         *self + rhs
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-params-in-different-spaces-3.stderr b/tests/ui/type/type-params-in-different-spaces-3.stderr
index c538d67316c..58783fe1ff0 100644
--- a/tests/ui/type/type-params-in-different-spaces-3.stderr
+++ b/tests/ui/type/type-params-in-different-spaces-3.stderr
@@ -15,6 +15,6 @@ LL |         u
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-recursive-box-shadowed.stderr b/tests/ui/type/type-recursive-box-shadowed.stderr
index cb0e982877c..8cc4eb36d82 100644
--- a/tests/ui/type/type-recursive-box-shadowed.stderr
+++ b/tests/ui/type/type-recursive-box-shadowed.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     inner: Box<Foo>,
    |            ++++   +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/type/type-shadow.stderr b/tests/ui/type/type-shadow.stderr
index 25b4bff4d9a..999ba4b5fc5 100644
--- a/tests/ui/type/type-shadow.stderr
+++ b/tests/ui/type/type-shadow.stderr
@@ -6,6 +6,6 @@ LL |         let y: Y = "hello";
    |                |
    |                expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type/type-unsatisfiable.usage.stderr b/tests/ui/type/type-unsatisfiable.usage.stderr
index 0b76ba8eb7e..b7c828b7479 100644
--- a/tests/ui/type/type-unsatisfiable.usage.stderr
+++ b/tests/ui/type/type-unsatisfiable.usage.stderr
@@ -6,6 +6,6 @@ LL |     let bar = *hey - *word;
    |               |
    |               dyn Vector2<ScalarType = i32>
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0369`.
diff --git a/tests/ui/type_length_limit.stderr b/tests/ui/type_length_limit.stderr
index 5b00d387aba..32290a2f5bf 100644
--- a/tests/ui/type_length_limit.stderr
+++ b/tests/ui/type_length_limit.stderr
@@ -4,5 +4,5 @@ error: reached the type-length limit while instantiating `std::mem::drop::<Optio
    = help: consider adding a `#![type_length_limit="10"]` attribute to your crate
    = note: the full type name has been written to '$TEST_BUILD_DIR/type_length_limit/type_length_limit.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/apit-with-error-type-in-sig.stderr b/tests/ui/typeck/apit-with-error-type-in-sig.stderr
index 49b2eac1b65..6ed9b1f9b8c 100644
--- a/tests/ui/typeck/apit-with-error-type-in-sig.stderr
+++ b/tests/ui/typeck/apit-with-error-type-in-sig.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Bar` in this scope
 LL | type Foo = Bar;
    |            ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/typeck/assign-non-lval-needs-deref.stderr b/tests/ui/typeck/assign-non-lval-needs-deref.stderr
index ee83b145321..28520b7ac54 100644
--- a/tests/ui/typeck/assign-non-lval-needs-deref.stderr
+++ b/tests/ui/typeck/assign-non-lval-needs-deref.stderr
@@ -11,6 +11,6 @@ help: consider dereferencing the left-hand side of this operation
 LL |     *(&mut Foo) += ();
    |     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0067`.
diff --git a/tests/ui/typeck/autoderef-with-param-env-error.stderr b/tests/ui/typeck/autoderef-with-param-env-error.stderr
index 182612d5ee7..e06be398aa0 100644
--- a/tests/ui/typeck/autoderef-with-param-env-error.stderr
+++ b/tests/ui/typeck/autoderef-with-param-env-error.stderr
@@ -9,6 +9,6 @@ help: you might be missing a type parameter
 LL | fn foo<T>()
    |       +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/typeck/bad-index-modulo-higher-ranked-regions.stderr b/tests/ui/typeck/bad-index-modulo-higher-ranked-regions.stderr
index 7c978430839..93c370fd893 100644
--- a/tests/ui/typeck/bad-index-modulo-higher-ranked-regions.stderr
+++ b/tests/ui/typeck/bad-index-modulo-higher-ranked-regions.stderr
@@ -4,6 +4,6 @@ error[E0608]: cannot index into a value of type `Map<[usize; 1], {closure@$DIR/b
 LL |     Map { inner: [0_usize], f: |_, i: usize| 1_usize }[0];
    |                                                       ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0608`.
diff --git a/tests/ui/typeck/bad-type-in-vec-contains.stderr b/tests/ui/typeck/bad-type-in-vec-contains.stderr
index b9b3a5fe5ec..de9bd33eb1c 100644
--- a/tests/ui/typeck/bad-type-in-vec-contains.stderr
+++ b/tests/ui/typeck/bad-type-in-vec-contains.stderr
@@ -15,6 +15,6 @@ help: consider borrowing here
 LL |     primes.contains(&3);
    |                     +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/call-block.stderr b/tests/ui/typeck/call-block.stderr
index 68984bc1c45..3c67cdd0fbc 100644
--- a/tests/ui/typeck/call-block.stderr
+++ b/tests/ui/typeck/call-block.stderr
@@ -6,6 +6,6 @@ LL |     let _ = {42}();
    |             |
    |             call expression requires function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/typeck/check-args-on-fn-err.stderr b/tests/ui/typeck/check-args-on-fn-err.stderr
index 864d33e0e93..be0798ab107 100644
--- a/tests/ui/typeck/check-args-on-fn-err.stderr
+++ b/tests/ui/typeck/check-args-on-fn-err.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `unknown` in this scope
 LL |     unknown(1, |glyf| {
    |     ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/typeck/derive-sugg-arg-arity.stderr b/tests/ui/typeck/derive-sugg-arg-arity.stderr
index 5b4c4817198..41b16a772ca 100644
--- a/tests/ui/typeck/derive-sugg-arg-arity.stderr
+++ b/tests/ui/typeck/derive-sugg-arg-arity.stderr
@@ -26,6 +26,6 @@ LL + #[derive(PartialEq, PartialOrd)]
 LL | pub struct A;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/dont-record-adjustments-when-pointing-at-arg.stderr b/tests/ui/typeck/dont-record-adjustments-when-pointing-at-arg.stderr
index 02e87d701b6..b651d80292d 100644
--- a/tests/ui/typeck/dont-record-adjustments-when-pointing-at-arg.stderr
+++ b/tests/ui/typeck/dont-record-adjustments-when-pointing-at-arg.stderr
@@ -12,6 +12,6 @@ note: method defined here
 LL |     fn setFrame_display_(self, display: ()) {}
    |        ^^^^^^^^^^^^^^^^^       -----------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/escaping_bound_vars.stderr b/tests/ui/typeck/escaping_bound_vars.stderr
index f7077e52a70..3ea40943577 100644
--- a/tests/ui/typeck/escaping_bound_vars.stderr
+++ b/tests/ui/typeck/escaping_bound_vars.stderr
@@ -6,5 +6,5 @@ LL |     (): Test<{ 1 + (<() as Elide(&())>::call) }>,
    |                                  |
    |                                  lifetime defined here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/issue-100246.stderr b/tests/ui/typeck/issue-100246.stderr
index 428a0792091..86eb163b471 100644
--- a/tests/ui/typeck/issue-100246.stderr
+++ b/tests/ui/typeck/issue-100246.stderr
@@ -8,6 +8,6 @@ LL |     let other: Other = downcast()?;
    = note: expected struct `Other`
            found reference `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-100285.stderr b/tests/ui/typeck/issue-100285.stderr
index 42c64b03918..9a1d5d964fa 100644
--- a/tests/ui/typeck/issue-100285.stderr
+++ b/tests/ui/typeck/issue-100285.stderr
@@ -29,6 +29,6 @@ LL |           return 2;
    = note: if the loop doesn't execute, 3 other values would never get returned
    = help: return a value for the case when the loop has zero elements to iterate on, or consider changing the return type to account for that possibility
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-10401.stderr b/tests/ui/typeck/issue-10401.stderr
index 1f68abcfb43..1b7daa9c2b9 100644
--- a/tests/ui/typeck/issue-10401.stderr
+++ b/tests/ui/typeck/issue-10401.stderr
@@ -6,6 +6,6 @@ LL |     a += { "b" };
    |     |
    |     cannot use `+=` on type `&str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0368`.
diff --git a/tests/ui/typeck/issue-104510-ice.stderr b/tests/ui/typeck/issue-104510-ice.stderr
index ddb510ef047..143139b2c08 100644
--- a/tests/ui/typeck/issue-104510-ice.stderr
+++ b/tests/ui/typeck/issue-104510-ice.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Oops` in this scope
 LL | struct W<T: ?Sized>(Oops);
    |                     ^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/typeck/issue-106929.stderr b/tests/ui/typeck/issue-106929.stderr
index f744e5a41f0..375c9372ec2 100644
--- a/tests/ui/typeck/issue-106929.stderr
+++ b/tests/ui/typeck/issue-106929.stderr
@@ -10,6 +10,6 @@ LL -     post(c, ());
 LL +     c.post(());
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/typeck/issue-107087.stderr b/tests/ui/typeck/issue-107087.stderr
index 8921e3f7694..289c8d161ae 100644
--- a/tests/ui/typeck/issue-107087.stderr
+++ b/tests/ui/typeck/issue-107087.stderr
@@ -4,6 +4,6 @@ error[E0223]: ambiguous associated type
 LL |     A::B::<>::C
    |     ^^^^^^^^ help: use fully-qualified syntax: `<A<_> as Foo>::B`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/typeck/issue-107775.stderr b/tests/ui/typeck/issue-107775.stderr
index b97e74b7e53..180b0183a3f 100644
--- a/tests/ui/typeck/issue-107775.stderr
+++ b/tests/ui/typeck/issue-107775.stderr
@@ -11,6 +11,6 @@ LL |         Self { map }
    = note: expected struct `HashMap<u16, fn(_) -> Pin<Box<(dyn Future<Output = ()> + Send + 'static)>>>`
               found struct `HashMap<{integer}, fn(_) -> Pin<Box<dyn Future<Output = ()> + Send>> {<Struct as Trait>::do_something::<'_>}>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-110052.stderr b/tests/ui/typeck/issue-110052.stderr
index 75374fa6121..b25b6c0c0b7 100644
--- a/tests/ui/typeck/issue-110052.stderr
+++ b/tests/ui/typeck/issue-110052.stderr
@@ -4,6 +4,6 @@ error[E0223]: ambiguous associated type
 LL |     for<'iter> dyn Validator<<&'iter I>::Item>:,
    |                              ^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: `<&'iter I as IntoIterator>::Item`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/typeck/issue-112385-while-assign-lhs-place-expr-ice.stderr b/tests/ui/typeck/issue-112385-while-assign-lhs-place-expr-ice.stderr
index cf2648d0840..c7d853428dd 100644
--- a/tests/ui/typeck/issue-112385-while-assign-lhs-place-expr-ice.stderr
+++ b/tests/ui/typeck/issue-112385-while-assign-lhs-place-expr-ice.stderr
@@ -9,6 +9,6 @@ help: consider adding `let`
 LL |     while let Some(foo) = None {}
    |           +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-114918/const-in-fn-return-type.stderr b/tests/ui/typeck/issue-114918/const-in-fn-return-type.stderr
index 88ed96e148c..02c212e2492 100644
--- a/tests/ui/typeck/issue-114918/const-in-fn-return-type.stderr
+++ b/tests/ui/typeck/issue-114918/const-in-fn-return-type.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL | fn func() -> [u8; { () } ] {
    |                     ^^ expected `usize`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-114918/const-in-struct-type-arg.stderr b/tests/ui/typeck/issue-114918/const-in-struct-type-arg.stderr
index 3307e76d957..5941ea188b5 100644
--- a/tests/ui/typeck/issue-114918/const-in-struct-type-arg.stderr
+++ b/tests/ui/typeck/issue-114918/const-in-struct-type-arg.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     let s = S::<{ () }> { arr: [5, 6, 7]};
    |                   ^^ expected `usize`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-114918/const-in-trait-fn-return-type.stderr b/tests/ui/typeck/issue-114918/const-in-trait-fn-return-type.stderr
index 6bc0de77a62..063e21f4023 100644
--- a/tests/ui/typeck/issue-114918/const-in-trait-fn-return-type.stderr
+++ b/tests/ui/typeck/issue-114918/const-in-trait-fn-return-type.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     fn func<const N: u32>() -> [ (); { () }] {
    |                                        ^^ expected `usize`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-13853-2.stderr b/tests/ui/typeck/issue-13853-2.stderr
index 92068df6c05..af50e8da7f0 100644
--- a/tests/ui/typeck/issue-13853-2.stderr
+++ b/tests/ui/typeck/issue-13853-2.stderr
@@ -9,6 +9,6 @@ help: use parentheses to call the method
 LL | fn foo(res : Box<dyn ResponseHook>) { res.get() }
    |                                              ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/typeck/issue-13853-5.stderr b/tests/ui/typeck/issue-13853-5.stderr
index 3d8f824ec94..1eead956328 100644
--- a/tests/ui/typeck/issue-13853-5.stderr
+++ b/tests/ui/typeck/issue-13853-5.stderr
@@ -4,6 +4,6 @@ error[E0207]: the type parameter `T` is not constrained by the impl trait, self
 LL | impl<'a, T: Deserializable> Deserializable for &'a str {
    |          ^ unconstrained type parameter
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/typeck/issue-1871.stderr b/tests/ui/typeck/issue-1871.stderr
index b774ca22dd7..808226015b5 100644
--- a/tests/ui/typeck/issue-1871.stderr
+++ b/tests/ui/typeck/issue-1871.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `honk` found for type `{integer}` in the current s
 LL |       f.honk()
    |         ^^^^ method not found in `{integer}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-18937.stderr b/tests/ui/typeck/issue-18937.stderr
index 5e2ba0ef4fc..0575751a896 100644
--- a/tests/ui/typeck/issue-18937.stderr
+++ b/tests/ui/typeck/issue-18937.stderr
@@ -9,6 +9,6 @@ LL | |               Self: Sized;
 LL |           where F: fmt::Debug + 'static,
    |                                 ^^^^^^^ impl has extra requirement `F: 'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0276`.
diff --git a/tests/ui/typeck/issue-33575.stderr b/tests/ui/typeck/issue-33575.stderr
index bbd8042d1cd..dc723952ff1 100644
--- a/tests/ui/typeck/issue-33575.stderr
+++ b/tests/ui/typeck/issue-33575.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `foo` found for unit type `()` in the current scop
 LL |     let baz = ().foo();
    |                  ^^^ method not found in `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-36708.stderr b/tests/ui/typeck/issue-36708.stderr
index f1e0f471928..3589796b6aa 100644
--- a/tests/ui/typeck/issue-36708.stderr
+++ b/tests/ui/typeck/issue-36708.stderr
@@ -9,6 +9,6 @@ LL |     fn foo<T>() {}
 LL |     fn foo();
    |     --------- expected 0 type parameters
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0049`.
diff --git a/tests/ui/typeck/issue-43189.stderr b/tests/ui/typeck/issue-43189.stderr
index c072e6a08ba..2e12651699d 100644
--- a/tests/ui/typeck/issue-43189.stderr
+++ b/tests/ui/typeck/issue-43189.stderr
@@ -15,6 +15,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL + use xcrate_issue_43189_b::xcrate_issue_43189_a::A;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-46112.stderr b/tests/ui/typeck/issue-46112.stderr
index 26fc21dda06..16beaea75db 100644
--- a/tests/ui/typeck/issue-46112.stderr
+++ b/tests/ui/typeck/issue-46112.stderr
@@ -22,6 +22,6 @@ help: try wrapping the expression in `Some`
 LL | fn main() { test(Ok(Some(()))); }
    |                     +++++  +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-50687-ice-on-borrow.stderr b/tests/ui/typeck/issue-50687-ice-on-borrow.stderr
index 9e48ccefd86..24dce469792 100644
--- a/tests/ui/typeck/issue-50687-ice-on-borrow.stderr
+++ b/tests/ui/typeck/issue-50687-ice-on-borrow.stderr
@@ -13,6 +13,6 @@ help: consider dereferencing the borrow
 LL |     let _: () = *Borrow::borrow(&owned);
    |                 +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-53712.stderr b/tests/ui/typeck/issue-53712.stderr
index 7ed9cb10379..ec31766324b 100644
--- a/tests/ui/typeck/issue-53712.stderr
+++ b/tests/ui/typeck/issue-53712.stderr
@@ -7,6 +7,6 @@ LL |     arr.0;
    |     |   unknown field
    |     help: instead of using tuple indexing, use array indexing: `arr[0]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/typeck/issue-57404.stderr b/tests/ui/typeck/issue-57404.stderr
index a631dbb39fb..4c1bfc0cbf7 100644
--- a/tests/ui/typeck/issue-57404.stderr
+++ b/tests/ui/typeck/issue-57404.stderr
@@ -14,6 +14,6 @@ LL -     handlers.unwrap().as_mut().call_mut(&mut ());
 LL +     handlers.unwrap().as_mut().call_mut(());
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/issue-57673-ice-on-deref-of-boxed-trait.stderr b/tests/ui/typeck/issue-57673-ice-on-deref-of-boxed-trait.stderr
index 6c3302f29c2..30183888062 100644
--- a/tests/ui/typeck/issue-57673-ice-on-deref-of-boxed-trait.stderr
+++ b/tests/ui/typeck/issue-57673-ice-on-deref-of-boxed-trait.stderr
@@ -9,6 +9,6 @@ LL |     *x
    = note: expected unit type `()`
            found trait object `(dyn Iterator<Item = ()> + 'static)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-69378-ice-on-invalid-type-node-after-recovery.stderr b/tests/ui/typeck/issue-69378-ice-on-invalid-type-node-after-recovery.stderr
index fc7c23a2252..1b70c6f9d02 100644
--- a/tests/ui/typeck/issue-69378-ice-on-invalid-type-node-after-recovery.stderr
+++ b/tests/ui/typeck/issue-69378-ice-on-invalid-type-node-after-recovery.stderr
@@ -6,5 +6,5 @@ LL | struct Foo { 0: u8 }
    |        |
    |        while parsing this struct
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/issue-7813.stderr b/tests/ui/typeck/issue-7813.stderr
index 2a747f679a8..953cbd206dc 100644
--- a/tests/ui/typeck/issue-7813.stderr
+++ b/tests/ui/typeck/issue-7813.stderr
@@ -9,6 +9,6 @@ help: consider giving `v` an explicit type, where the placeholders `_` are speci
 LL |     let v: &[_; 0] = &[];
    |          +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/typeck/issue-83621-placeholder-static-in-extern.stderr b/tests/ui/typeck/issue-83621-placeholder-static-in-extern.stderr
index 9376e8bcf80..a4cb53025e3 100644
--- a/tests/ui/typeck/issue-83621-placeholder-static-in-extern.stderr
+++ b/tests/ui/typeck/issue-83621-placeholder-static-in-extern.stderr
@@ -4,6 +4,6 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL |     static x: _;
    |               ^ not allowed in type signatures
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/typeck/issue-84160.stderr b/tests/ui/typeck/issue-84160.stderr
index 4d456ae842f..1dc798b5e22 100644
--- a/tests/ui/typeck/issue-84160.stderr
+++ b/tests/ui/typeck/issue-84160.stderr
@@ -10,6 +10,6 @@ LL |     return "test";
    = note: expected reference `&u32`
               found reference `&'static str`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-86721-return-expr-ice.rev1.stderr b/tests/ui/typeck/issue-86721-return-expr-ice.rev1.stderr
index b1111fcf148..36ae7d5de1b 100644
--- a/tests/ui/typeck/issue-86721-return-expr-ice.rev1.stderr
+++ b/tests/ui/typeck/issue-86721-return-expr-ice.rev1.stderr
@@ -4,6 +4,6 @@ error[E0572]: return statement outside of function body
 LL |     const U: usize = return;
    |                      ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/typeck/issue-86721-return-expr-ice.rev2.stderr b/tests/ui/typeck/issue-86721-return-expr-ice.rev2.stderr
index f489ae2002a..ff781a68dc6 100644
--- a/tests/ui/typeck/issue-86721-return-expr-ice.rev2.stderr
+++ b/tests/ui/typeck/issue-86721-return-expr-ice.rev2.stderr
@@ -4,6 +4,6 @@ error[E0572]: return statement outside of function body
 LL |     fn foo(a: [(); return]);
    |                    ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0572`.
diff --git a/tests/ui/typeck/issue-87181/empty-tuple-method.stderr b/tests/ui/typeck/issue-87181/empty-tuple-method.stderr
index f0ca49e6d1e..a34ed08376a 100644
--- a/tests/ui/typeck/issue-87181/empty-tuple-method.stderr
+++ b/tests/ui/typeck/issue-87181/empty-tuple-method.stderr
@@ -9,6 +9,6 @@ help: use parentheses to construct this tuple struct
 LL |     (thing.bar)().foo();
    |     +         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-87181/enum-variant.stderr b/tests/ui/typeck/issue-87181/enum-variant.stderr
index d313a887abd..800369b5176 100644
--- a/tests/ui/typeck/issue-87181/enum-variant.stderr
+++ b/tests/ui/typeck/issue-87181/enum-variant.stderr
@@ -9,6 +9,6 @@ help: use parentheses to construct this tuple variant
 LL |     (thing.bar)().foo();
    |     +         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-87181/tuple-field.stderr b/tests/ui/typeck/issue-87181/tuple-field.stderr
index 16afac4bd6b..e4b5a155e49 100644
--- a/tests/ui/typeck/issue-87181/tuple-field.stderr
+++ b/tests/ui/typeck/issue-87181/tuple-field.stderr
@@ -9,6 +9,6 @@ help: use parentheses to construct this tuple struct
 LL |     (thing.bar)(/* char */, /* u16 */).0;
    |     +         ++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/typeck/issue-87181/tuple-method.stderr b/tests/ui/typeck/issue-87181/tuple-method.stderr
index de3dc15a54b..87145d9bbd6 100644
--- a/tests/ui/typeck/issue-87181/tuple-method.stderr
+++ b/tests/ui/typeck/issue-87181/tuple-method.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `foo` found for struct constructor `fn(u8, i32) ->
 LL |     thing.bar.foo();
    |               ^^^ method not found in `fn(u8, i32) -> Foo {Foo}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr b/tests/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr
index 56817ee2ca9..93c52f3c5b3 100644
--- a/tests/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr
+++ b/tests/ui/typeck/issue-87771-ice-assign-assign-to-bool.stderr
@@ -6,6 +6,6 @@ LL |     let mut a;
 LL |     a = a = true;
    |         ^^^^^^^^ expected `bool`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-87872-missing-inaccessible-field-literal.stderr b/tests/ui/typeck/issue-87872-missing-inaccessible-field-literal.stderr
index f0bd3e0ddf7..eab494ffbdf 100644
--- a/tests/ui/typeck/issue-87872-missing-inaccessible-field-literal.stderr
+++ b/tests/ui/typeck/issue-87872-missing-inaccessible-field-literal.stderr
@@ -6,5 +6,5 @@ LL |     foo::Foo {};
    |
    = note: ... and other private field `you_cant_use_this_field` that was not provided
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/issue-87872-missing-inaccessible-field-pattern.stderr b/tests/ui/typeck/issue-87872-missing-inaccessible-field-pattern.stderr
index dc30975103c..96ac481438f 100644
--- a/tests/ui/typeck/issue-87872-missing-inaccessible-field-pattern.stderr
+++ b/tests/ui/typeck/issue-87872-missing-inaccessible-field-pattern.stderr
@@ -13,6 +13,6 @@ help: if you don't care about this missing field, you can explicitly ignore it
 LL |     let foo::Foo { .. } = foo::Foo::default();
    |                  ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0027`.
diff --git a/tests/ui/typeck/issue-88803-call-expr-method.stderr b/tests/ui/typeck/issue-88803-call-expr-method.stderr
index 645c04b87a1..ebae93cee2b 100644
--- a/tests/ui/typeck/issue-88803-call-expr-method.stderr
+++ b/tests/ui/typeck/issue-88803-call-expr-method.stderr
@@ -10,6 +10,6 @@ LL -         (a.unwrap)()
 LL +         a.unwrap()
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/typeck/issue-88844.stderr b/tests/ui/typeck/issue-88844.stderr
index 90bba90be34..68473f65dcf 100644
--- a/tests/ui/typeck/issue-88844.stderr
+++ b/tests/ui/typeck/issue-88844.stderr
@@ -7,6 +7,6 @@ LL | struct Struct { value: i32 }
 LL | impl Stuct {
    |      ^^^^^ help: a struct with a similar name exists: `Struct`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/typeck/issue-89044-wrapped-expr-method.stderr b/tests/ui/typeck/issue-89044-wrapped-expr-method.stderr
index 6fa0915dcaf..bb407fdb8a9 100644
--- a/tests/ui/typeck/issue-89044-wrapped-expr-method.stderr
+++ b/tests/ui/typeck/issue-89044-wrapped-expr-method.stderr
@@ -9,6 +9,6 @@ help: use parentheses to call the method
 LL |         (a.unwrap())
    |                  ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/typeck/issue-89275.stderr b/tests/ui/typeck/issue-89275.stderr
index d73e647d21f..6686d5f977e 100644
--- a/tests/ui/typeck/issue-89275.stderr
+++ b/tests/ui/typeck/issue-89275.stderr
@@ -9,6 +9,6 @@ LL |     let other: &mut Other = downcast();
    = note: expected mutable reference `&mut Other`
                       found reference `&_`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-89806.stderr b/tests/ui/typeck/issue-89806.stderr
index c36b4967ee9..554a06cb6af 100644
--- a/tests/ui/typeck/issue-89806.stderr
+++ b/tests/ui/typeck/issue-89806.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `as_ref` found for type `u8` in the current scope
 LL |     0u8.as_ref();
    |         ^^^^^^ method not found in `u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/issue-90101.stderr b/tests/ui/typeck/issue-90101.stderr
index 484089f9e87..a24f9cb540f 100644
--- a/tests/ui/typeck/issue-90101.stderr
+++ b/tests/ui/typeck/issue-90101.stderr
@@ -19,6 +19,6 @@ note: required by a bound in `func`
 LL | fn func(path: impl Into<PathBuf>, code: impl Into<String>) {}
    |                    ^^^^^^^^^^^^^ required by this bound in `func`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/issue-90164.stderr b/tests/ui/typeck/issue-90164.stderr
index 8586f522291..43e96e1adc6 100644
--- a/tests/ui/typeck/issue-90164.stderr
+++ b/tests/ui/typeck/issue-90164.stderr
@@ -18,6 +18,6 @@ help: consider restricting type parameter `T`
 LL | fn f<T: std::marker::Unpin>(r: T) {
    |       ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/issue-90319.stderr b/tests/ui/typeck/issue-90319.stderr
index 61549dd701e..fa18056e802 100644
--- a/tests/ui/typeck/issue-90319.stderr
+++ b/tests/ui/typeck/issue-90319.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Thing` in this scope
 LL |     let thing = get::<Thing>();
    |                       ^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/typeck/issue-90483-inaccessible-field-adjustment.stderr b/tests/ui/typeck/issue-90483-inaccessible-field-adjustment.stderr
index 02cdc102c15..fff9f5da16f 100644
--- a/tests/ui/typeck/issue-90483-inaccessible-field-adjustment.stderr
+++ b/tests/ui/typeck/issue-90483-inaccessible-field-adjustment.stderr
@@ -9,6 +9,6 @@ help: a method `foo` also exists, call it with parentheses
 LL |   || s.foo() + s.foo();
    |                     ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/typeck/issue-90804-incorrect-reference-suggestion.stderr b/tests/ui/typeck/issue-90804-incorrect-reference-suggestion.stderr
index a75024aa248..2d4069f5029 100644
--- a/tests/ui/typeck/issue-90804-incorrect-reference-suggestion.stderr
+++ b/tests/ui/typeck/issue-90804-incorrect-reference-suggestion.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `check`
 LL | pub fn check<T: Marker<u32>>(_: T) {}
    |                 ^^^^^^^^^^^ required by this bound in `check`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/issue-91210-ptr-method.stderr b/tests/ui/typeck/issue-91210-ptr-method.stderr
index 7a0cfb2cf51..f2f996c7b30 100644
--- a/tests/ui/typeck/issue-91210-ptr-method.stderr
+++ b/tests/ui/typeck/issue-91210-ptr-method.stderr
@@ -9,6 +9,6 @@ help: to access the field, dereference first
 LL |     (*x).read = 4;
    |     ++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/typeck/issue-92481.stderr b/tests/ui/typeck/issue-92481.stderr
index d87d3277d56..a1fdd8359a6 100644
--- a/tests/ui/typeck/issue-92481.stderr
+++ b/tests/ui/typeck/issue-92481.stderr
@@ -7,5 +7,5 @@ LL | fn r({) {
    |     |unclosed delimiter
    |     closing delimiter possibly meant for this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/issue-93486.stderr b/tests/ui/typeck/issue-93486.stderr
index 167edc8942a..c1489d9bcaa 100644
--- a/tests/ui/typeck/issue-93486.stderr
+++ b/tests/ui/typeck/issue-93486.stderr
@@ -11,6 +11,6 @@ help: consider dereferencing here to assign to the mutably borrowed value
 LL |         *vec![].last_mut().unwrap() = 3_u8;
    |         +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0070`.
diff --git a/tests/ui/typeck/issue-96530.stderr b/tests/ui/typeck/issue-96530.stderr
index 3a67ef0260b..d2fb8169ffc 100644
--- a/tests/ui/typeck/issue-96530.stderr
+++ b/tests/ui/typeck/issue-96530.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |         ..man.clone()
    |           ^^^^^^^^^^^ expected `Person`, found `&Person`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/issue-98260.stderr b/tests/ui/typeck/issue-98260.stderr
index 08a1d17e244..b7debd335b0 100644
--- a/tests/ui/typeck/issue-98260.stderr
+++ b/tests/ui/typeck/issue-98260.stderr
@@ -7,6 +7,6 @@ LL |     fn a(aa: B) -> Result<_, B> {
    |                    |      not allowed in type signatures
    |                    help: replace with the correct return type: `Result<(), B>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/ui/typeck/issue-98982.stderr b/tests/ui/typeck/issue-98982.stderr
index 3c9806ac965..c854460c34c 100644
--- a/tests/ui/typeck/issue-98982.stderr
+++ b/tests/ui/typeck/issue-98982.stderr
@@ -19,6 +19,6 @@ LL |         return i;
    |         -------- if the loop doesn't execute, this value would never get returned
    = help: return a value for the case when the loop has zero elements to iterate on, or consider changing the return type to account for that possibility
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/missing-private-fields-in-struct-literal.stderr b/tests/ui/typeck/missing-private-fields-in-struct-literal.stderr
index 234110f31f7..96998ca244d 100644
--- a/tests/ui/typeck/missing-private-fields-in-struct-literal.stderr
+++ b/tests/ui/typeck/missing-private-fields-in-struct-literal.stderr
@@ -11,5 +11,5 @@ LL |         b: (),
    |
    = note: ... and other private fields `c`, `d` and `e` that were not provided
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/no-type-for-node-ice.stderr b/tests/ui/typeck/no-type-for-node-ice.stderr
index b990b5f951f..a79d6b600eb 100644
--- a/tests/ui/typeck/no-type-for-node-ice.stderr
+++ b/tests/ui/typeck/no-type-for-node-ice.stderr
@@ -4,6 +4,6 @@ error[E0609]: no field `homura` on type `&'static str`
 LL |     "".homura[""];
    |        ^^^^^^ unknown field
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/typeck/nonexistent-field-not-ambiguous.stderr b/tests/ui/typeck/nonexistent-field-not-ambiguous.stderr
index 76a2a5f99f2..82207a731b9 100644
--- a/tests/ui/typeck/nonexistent-field-not-ambiguous.stderr
+++ b/tests/ui/typeck/nonexistent-field-not-ambiguous.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `MissingType` in this scope
 LL |     val: MissingType,
    |          ^^^^^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/typeck/output-type-mismatch.stderr b/tests/ui/typeck/output-type-mismatch.stderr
index 4507a4df621..c6df6650654 100644
--- a/tests/ui/typeck/output-type-mismatch.stderr
+++ b/tests/ui/typeck/output-type-mismatch.stderr
@@ -6,6 +6,6 @@ LL | fn main() { let i: isize; i = f(); }
    |                    |
    |                    expected due to this type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/path-to-method-sugg-unresolved-expr.stderr b/tests/ui/typeck/path-to-method-sugg-unresolved-expr.stderr
index b01e30be54d..3e03c17f3b1 100644
--- a/tests/ui/typeck/path-to-method-sugg-unresolved-expr.stderr
+++ b/tests/ui/typeck/path-to-method-sugg-unresolved-expr.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `page_size`
 LL |     let page_size = page_size::get();
    |                     ^^^^^^^^^ use of undeclared crate or module `page_size`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/typeck/point-at-type-param-in-path-expr.stderr b/tests/ui/typeck/point-at-type-param-in-path-expr.stderr
index 1feaa0508bf..14642b25c99 100644
--- a/tests/ui/typeck/point-at-type-param-in-path-expr.stderr
+++ b/tests/ui/typeck/point-at-type-param-in-path-expr.stderr
@@ -12,6 +12,6 @@ note: required by a bound in `foo`
 LL | fn foo<T: std::fmt::Display>() {}
    |           ^^^^^^^^^^^^^^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/point-at-type-parameter-definition.stderr b/tests/ui/typeck/point-at-type-parameter-definition.stderr
index 8a6ab61100d..bfe01f3614e 100644
--- a/tests/ui/typeck/point-at-type-parameter-definition.stderr
+++ b/tests/ui/typeck/point-at-type-parameter-definition.stderr
@@ -7,6 +7,6 @@ LL |     fn do_stuff(&self) {
 LL |         self[0].method();
    |                 ^^^^^^ method not found in `Hello`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/typeck/ptr-null-mutability-suggestions.stderr b/tests/ui/typeck/ptr-null-mutability-suggestions.stderr
index 705b029bdea..b615d9fb45c 100644
--- a/tests/ui/typeck/ptr-null-mutability-suggestions.stderr
+++ b/tests/ui/typeck/ptr-null-mutability-suggestions.stderr
@@ -16,6 +16,6 @@ note: function defined here
 LL | fn expecting_null_mut(_: *mut u8) {}
    |    ^^^^^^^^^^^^^^^^^^ ----------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/quiet-type-err-let-binding.stderr b/tests/ui/typeck/quiet-type-err-let-binding.stderr
index ad7f85e01ec..f27ca1dd582 100644
--- a/tests/ui/typeck/quiet-type-err-let-binding.stderr
+++ b/tests/ui/typeck/quiet-type-err-let-binding.stderr
@@ -4,6 +4,6 @@ error[E0425]: cannot find function `foo` in this scope
 LL |     let x = foo();
    |             ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/typeck/remove-extra-argument.stderr b/tests/ui/typeck/remove-extra-argument.stderr
index 72ddebab486..9557c41457d 100644
--- a/tests/ui/typeck/remove-extra-argument.stderr
+++ b/tests/ui/typeck/remove-extra-argument.stderr
@@ -13,6 +13,6 @@ note: function defined here
 LL | fn l(_a: Vec<u8>) {}
    |    ^ -----------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0061`.
diff --git a/tests/ui/typeck/repeat-expr-checks-wf.stderr b/tests/ui/typeck/repeat-expr-checks-wf.stderr
index a821088a4b3..8d5b57ead03 100644
--- a/tests/ui/typeck/repeat-expr-checks-wf.stderr
+++ b/tests/ui/typeck/repeat-expr-checks-wf.stderr
@@ -7,6 +7,6 @@ LL |     let a = [T::ASSOC; 2];
    = help: the trait `Sized` is not implemented for `[u8]`
    = note: slice and array elements must have `Sized` type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/return-dyn-type-mismatch-2.stderr b/tests/ui/typeck/return-dyn-type-mismatch-2.stderr
index 9c368e83834..77299621ab9 100644
--- a/tests/ui/typeck/return-dyn-type-mismatch-2.stderr
+++ b/tests/ui/typeck/return-dyn-type-mismatch-2.stderr
@@ -10,6 +10,6 @@ LL |     42
    = note: expected trait object `(dyn Trait<T> + 'static)`
                       found type `{integer}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/return-dyn-type-mismatch.stderr b/tests/ui/typeck/return-dyn-type-mismatch.stderr
index 9d0a609d87f..064d0d64e07 100644
--- a/tests/ui/typeck/return-dyn-type-mismatch.stderr
+++ b/tests/ui/typeck/return-dyn-type-mismatch.stderr
@@ -10,6 +10,6 @@ LL |             None => None,
    = note: expected trait object `(dyn TestTrait<MyType = T> + 'static)`
                       found enum `Option<_>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/return_type_containing_closure.stderr b/tests/ui/typeck/return_type_containing_closure.stderr
index 7be46ac073e..ea9c74be362 100644
--- a/tests/ui/typeck/return_type_containing_closure.stderr
+++ b/tests/ui/typeck/return_type_containing_closure.stderr
@@ -15,6 +15,6 @@ help: a return type might be missing here
 LL | fn foo() -> _ {
    |          ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/suppressed-error.stderr b/tests/ui/typeck/suppressed-error.stderr
index 11d70f8a433..0b68fc97e78 100644
--- a/tests/ui/typeck/suppressed-error.stderr
+++ b/tests/ui/typeck/suppressed-error.stderr
@@ -9,6 +9,6 @@ LL |     let (x, y) = ();
    = note: expected unit type `()`
                   found tuple `(_, _)`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/tag-that-dare-not-speak-its-name.stderr b/tests/ui/typeck/tag-that-dare-not-speak-its-name.stderr
index c4f16429563..3a7e2068ca6 100644
--- a/tests/ui/typeck/tag-that-dare-not-speak-its-name.stderr
+++ b/tests/ui/typeck/tag-that-dare-not-speak-its-name.stderr
@@ -13,6 +13,6 @@ help: consider using `Option::expect` to unwrap the `Option<_>` value, panicking
 LL |     let x : char = last(y).expect("REASON");
    |                           +++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/terr-in-field.stderr b/tests/ui/typeck/terr-in-field.stderr
index 09df4b34bb5..adc336db501 100644
--- a/tests/ui/typeck/terr-in-field.stderr
+++ b/tests/ui/typeck/terr-in-field.stderr
@@ -12,6 +12,6 @@ note: function defined here
 LL | fn want_foo(f: Foo) {}
    |    ^^^^^^^^ ------
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/terr-sorts.stderr b/tests/ui/typeck/terr-sorts.stderr
index 8f1975374a5..59d9392c236 100644
--- a/tests/ui/typeck/terr-sorts.stderr
+++ b/tests/ui/typeck/terr-sorts.stderr
@@ -18,6 +18,6 @@ help: consider unboxing the value
 LL |     want_foo(*b);
    |              +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/typeck-cast-pointer-to-float.stderr b/tests/ui/typeck/typeck-cast-pointer-to-float.stderr
index 81d968454be..670ff73e28b 100644
--- a/tests/ui/typeck/typeck-cast-pointer-to-float.stderr
+++ b/tests/ui/typeck/typeck-cast-pointer-to-float.stderr
@@ -4,6 +4,6 @@ error[E0606]: casting `*const i16` as `f32` is invalid
 LL |     ((&x) as *const i16) as f32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0606`.
diff --git a/tests/ui/typeck/typeck-default-trait-impl-assoc-type.stderr b/tests/ui/typeck/typeck-default-trait-impl-assoc-type.stderr
index 468a14762c0..cedb1b13b1e 100644
--- a/tests/ui/typeck/typeck-default-trait-impl-assoc-type.stderr
+++ b/tests/ui/typeck/typeck-default-trait-impl-assoc-type.stderr
@@ -15,6 +15,6 @@ help: consider further restricting the associated type
 LL | fn bar<T:Trait+Send>() where <T as Trait>::AssocType: Send {
    |                        +++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/typeck-default-trait-impl-negation-send.stderr b/tests/ui/typeck/typeck-default-trait-impl-negation-send.stderr
index 2ce32990e55..771272ad10b 100644
--- a/tests/ui/typeck/typeck-default-trait-impl-negation-send.stderr
+++ b/tests/ui/typeck/typeck-default-trait-impl-negation-send.stderr
@@ -11,6 +11,6 @@ note: required by a bound in `is_send`
 LL | fn is_send<T: Send>() {}
    |               ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr b/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
index 887a1ddbb69..537ae6b2b5f 100644
--- a/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
+++ b/tests/ui/typeck/typeck-default-trait-impl-send-param.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | fn foo<T: std::marker::Send>() {
    |         +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/typeck/typeck_type_placeholder_lifetime_1.stderr b/tests/ui/typeck/typeck_type_placeholder_lifetime_1.stderr
index c4e4aed2067..e4b1c02c201 100644
--- a/tests/ui/typeck/typeck_type_placeholder_lifetime_1.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_lifetime_1.stderr
@@ -12,6 +12,6 @@ note: struct defined here, with 1 generic parameter: `T`
 LL | struct Foo<'a, T:'a> {
    |        ^^^     -
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/typeck/typeck_type_placeholder_lifetime_2.stderr b/tests/ui/typeck/typeck_type_placeholder_lifetime_2.stderr
index 302231777bd..fcb5ecc4042 100644
--- a/tests/ui/typeck/typeck_type_placeholder_lifetime_2.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_lifetime_2.stderr
@@ -12,6 +12,6 @@ note: struct defined here, with 1 generic parameter: `T`
 LL | struct Foo<'a, T:'a> {
    |        ^^^     -
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/typeck/while-loop-block-cond.stderr b/tests/ui/typeck/while-loop-block-cond.stderr
index 598273af9cf..7f67650fd4c 100644
--- a/tests/ui/typeck/while-loop-block-cond.stderr
+++ b/tests/ui/typeck/while-loop-block-cond.stderr
@@ -4,6 +4,6 @@ error[E0308]: mismatched types
 LL |     while {} {}
    |           ^^ expected `bool`, found `()`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/while-type-error.stderr b/tests/ui/typeck/while-type-error.stderr
index 529cbff0563..b67ec561531 100644
--- a/tests/ui/typeck/while-type-error.stderr
+++ b/tests/ui/typeck/while-type-error.stderr
@@ -7,6 +7,6 @@ LL | fn main() { while main { } }
    = note: expected type `bool`
            found fn item `fn() {main}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/wrong-ret-type.stderr b/tests/ui/typeck/wrong-ret-type.stderr
index c686a0b2f5a..33a094ce95d 100644
--- a/tests/ui/typeck/wrong-ret-type.stderr
+++ b/tests/ui/typeck/wrong-ret-type.stderr
@@ -11,6 +11,6 @@ help: you can convert an `isize` to a `usize` and panic if the converted value d
 LL | fn mk_int() -> usize { let i: isize = 3; return i.try_into().unwrap(); }
    |                                                  ++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeof/issue-100183.stderr b/tests/ui/typeof/issue-100183.stderr
index 01d3079b246..7be923d9383 100644
--- a/tests/ui/typeof/issue-100183.stderr
+++ b/tests/ui/typeof/issue-100183.stderr
@@ -9,6 +9,6 @@ help: consider replacing `typeof(...)` with an actual type
 LL |     y: (&'static str,),
    |         ~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0516`.
diff --git a/tests/ui/typeof/issue-29184.stderr b/tests/ui/typeof/issue-29184.stderr
index 75b6c64f2ce..f07c850e556 100644
--- a/tests/ui/typeof/issue-29184.stderr
+++ b/tests/ui/typeof/issue-29184.stderr
@@ -9,6 +9,6 @@ help: consider replacing `typeof(...)` with an actual type
 LL |     let x: i32 = 92;
    |            ~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0516`.
diff --git a/tests/ui/unboxed-closures/issue-30906.stderr b/tests/ui/unboxed-closures/issue-30906.stderr
index 147a2097473..0815ae1fb5a 100644
--- a/tests/ui/unboxed-closures/issue-30906.stderr
+++ b/tests/ui/unboxed-closures/issue-30906.stderr
@@ -7,5 +7,5 @@ LL |     test(Compose(f, |_| {}));
    = note: `fn(&'2 str) -> T` must implement `FnOnce<(&'1 str,)>`, for any lifetime `'1`...
    = note: ...but it actually implements `FnOnce<(&'2 str,)>`, for some specific lifetime `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr b/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
index cfbe1c6f2cb..66d393c67c5 100644
--- a/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
+++ b/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
@@ -7,6 +7,6 @@ LL | fn a<F: Fn<usize>>(f: F) {}
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0059`.
diff --git a/tests/ui/unboxed-closures/non-tupled-call.stderr b/tests/ui/unboxed-closures/non-tupled-call.stderr
index 35ac9ebe291..207438bc9d8 100644
--- a/tests/ui/unboxed-closures/non-tupled-call.stderr
+++ b/tests/ui/unboxed-closures/non-tupled-call.stderr
@@ -4,6 +4,6 @@ error[E0059]: cannot use call notation; the first type parameter for the functio
 LL |     func(x);
    |     ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0059`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-feature-gate.stderr b/tests/ui/unboxed-closures/unboxed-closure-feature-gate.stderr
index b824d160d71..d06fa3007df 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-feature-gate.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-feature-gate.stderr
@@ -7,6 +7,6 @@ LL |     let x: Box<dyn Foo(isize)>;
    = note: see issue #29625 <https://github.com/rust-lang/rust/issues/29625> for more information
    = help: add `#![feature(unboxed_closures)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-no-cyclic-sig.stderr b/tests/ui/unboxed-closures/unboxed-closure-no-cyclic-sig.stderr
index 9d3c1902cf3..563167f3c0b 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-no-cyclic-sig.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-no-cyclic-sig.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `g`
 LL | fn g<F>(_: F) where F: FnOnce(Option<F>) {}
    |                        ^^^^^^^^^^^^^^^^^ required by this bound in `g`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0644`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-region.stderr b/tests/ui/unboxed-closures/unboxed-closure-region.stderr
index 43e9af24a7c..70407628f1d 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-region.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-region.stderr
@@ -16,6 +16,6 @@ help: to force the closure to take ownership of `x` (and any other referenced va
 LL |         move || x
    |         ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0373`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-sugar-default.stderr b/tests/ui/unboxed-closures/unboxed-closure-sugar-default.stderr
index a3b32d2c1c8..b5cef0b3a27 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-sugar-default.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-sugar-default.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `eq`
 LL | fn eq<A: ?Sized,B: ?Sized>() where A : Eq<B> { }
    |                                        ^^^^^ required by this bound in `eq`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-sugar-equiv.stderr b/tests/ui/unboxed-closures/unboxed-closure-sugar-equiv.stderr
index bccbf307ae1..923f1a34513 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-sugar-equiv.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-sugar-equiv.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `eq`
 LL | fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { }
    |                            ^^^^^ required by this bound in `eq`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-sugar-lifetime-elision.stderr b/tests/ui/unboxed-closures/unboxed-closure-sugar-lifetime-elision.stderr
index 2b8fec86c8a..b7e9e1baa7b 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-sugar-lifetime-elision.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-sugar-lifetime-elision.stderr
@@ -19,6 +19,6 @@ LL |
 LL ~     let _: dyn Foo(&'a isize, &'a usize) -> &'a usize;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-sugar-region.stderr b/tests/ui/unboxed-closures/unboxed-closure-sugar-region.stderr
index 8814617814c..0465c20dffa 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-sugar-region.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-sugar-region.stderr
@@ -10,6 +10,6 @@ note: trait defined here, with 1 lifetime parameter: `'a`
 LL | trait Foo<'a,T> {
    |       ^^^ --
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-3.stderr b/tests/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-3.stderr
index 4df404e8198..ce2c90f97da 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-3.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-sugar-used-on-struct-3.stderr
@@ -9,6 +9,6 @@ help: use angle brackets instead
 LL |     let b = Bar::<isize, usize>::new(); // OK too (for the parser)
    |                  ~            ~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0214`.
diff --git a/tests/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-1.stderr b/tests/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-1.stderr
index e4772478bd9..b8fb0702a08 100644
--- a/tests/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-1.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closure-sugar-wrong-number-number-type-parameters-1.stderr
@@ -4,6 +4,6 @@ error[E0220]: associated type `Output` not found for `One`
 LL | fn foo(_: &dyn One())
    |                ^^^^^ associated type `Output` not found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-borrow-conflict.stderr b/tests/ui/unboxed-closures/unboxed-closures-borrow-conflict.stderr
index 98fe97c5c18..4adf24162a0 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-borrow-conflict.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-borrow-conflict.stderr
@@ -10,6 +10,6 @@ LL |     let _y = x;
 LL |     f;
    |     - borrow later used here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0503`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr b/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr
index ff2a597bed0..5a76ef3e875 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr
@@ -12,6 +12,6 @@ help: consider giving `closure0` an explicit type, where the placeholders `_` ar
 LL |     let mut closure0: Option<T> = None;
    |                     +++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-fnmut-as-fn.stderr b/tests/ui/unboxed-closures/unboxed-closures-fnmut-as-fn.stderr
index ce4d0fe25f5..795bd0a0d18 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-fnmut-as-fn.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-fnmut-as-fn.stderr
@@ -14,6 +14,6 @@ note: required by a bound in `call_it`
 LL | fn call_it<F:Fn(isize)->isize>(f: &F, x: isize) -> isize {
    |              ^^^^^^^^^^^^^^^^ required by this bound in `call_it`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-infer-argument-types-two-region-pointers.stderr b/tests/ui/unboxed-closures/unboxed-closures-infer-argument-types-two-region-pointers.stderr
index e97157b8398..40d34140245 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-infer-argument-types-two-region-pointers.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-infer-argument-types-two-region-pointers.stderr
@@ -8,5 +8,5 @@ LL |     doit(0, &|x, y| {
 LL |         x.set(y);
    |         ^^^^^^^^ argument requires that `'1` must outlive `'2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/unboxed-closures/unboxed-closures-infer-fn-once-move-from-projection.stderr b/tests/ui/unboxed-closures/unboxed-closures-infer-fn-once-move-from-projection.stderr
index 846a44ce4d7..cc81ce9bc36 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-infer-fn-once-move-from-projection.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-infer-fn-once-move-from-projection.stderr
@@ -18,6 +18,6 @@ LL | fn foo<F>(f: F)
 LL |     where F: Fn()
    |              ^^^^ required by this bound in `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0525`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-missing-mut.stderr b/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-missing-mut.stderr
index 3f539c42d9b..b18f67a9983 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-missing-mut.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-missing-mut.stderr
@@ -11,6 +11,6 @@ help: consider changing this to be mutable
 LL |     let mut tick = || counter += 1;
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-move-missing-mut.stderr b/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-move-missing-mut.stderr
index e3b19297b9c..1c465f40947 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-move-missing-mut.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-infer-fnmut-move-missing-mut.stderr
@@ -11,6 +11,6 @@ help: consider changing this to be mutable
 LL |     let mut tick = move || counter += 1;
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr b/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr
index ab6f0651846..7013529a857 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr
@@ -17,6 +17,6 @@ note: this value implements `FnOnce`, which causes it to be moved when called
 LL |     tick();
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr b/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr
index 8d70a2b1760..2884dbfd29d 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr
@@ -17,6 +17,6 @@ note: this value implements `FnOnce`, which causes it to be moved when called
 LL |     tick();
    |     ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-mutated-upvar-from-fn-closure.stderr b/tests/ui/unboxed-closures/unboxed-closures-mutated-upvar-from-fn-closure.stderr
index 7d15cd0c882..cbe42861d5e 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-mutated-upvar-from-fn-closure.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-mutated-upvar-from-fn-closure.stderr
@@ -11,6 +11,6 @@ LL |     call(|| {
 LL |         counter += 1;
    |         ^^^^^^^^^^^^ cannot assign
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0594`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-recursive-fn-using-fn-mut.stderr b/tests/ui/unboxed-closures/unboxed-closures-recursive-fn-using-fn-mut.stderr
index 830f6bc993d..178cabd424d 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-recursive-fn-using-fn-mut.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-recursive-fn-using-fn-mut.stderr
@@ -7,6 +7,6 @@ LL |         (self.func)(self, arg)
    |         first mutable borrow occurs here
    |         first borrow later used by call
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/unboxed-closures/unboxed-closures-static-call-wrong-trait.stderr b/tests/ui/unboxed-closures/unboxed-closures-static-call-wrong-trait.stderr
index e2d867ff266..4d5e6f47965 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-static-call-wrong-trait.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-static-call-wrong-trait.stderr
@@ -4,6 +4,6 @@ error[E0599]: no method named `call` found for closure `{closure@$DIR/unboxed-cl
 LL |     mut_.call((0, ));
    |          ^^^^ method not found in `{closure@unboxed-closures-static-call-wrong-trait.rs:6:26}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/unconstrained-none.stderr b/tests/ui/unconstrained-none.stderr
index 19ac74fdf58..4af6f412e5b 100644
--- a/tests/ui/unconstrained-none.stderr
+++ b/tests/ui/unconstrained-none.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     None::<T>;
    |         +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/unconstrained-ref.stderr b/tests/ui/unconstrained-ref.stderr
index 1df6d8b446d..72fd0202f4e 100644
--- a/tests/ui/unconstrained-ref.stderr
+++ b/tests/ui/unconstrained-ref.stderr
@@ -9,6 +9,6 @@ help: consider specifying the generic argument
 LL |     S::<T> { o: &None };
    |      +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/underscore-ident-matcher.stderr b/tests/ui/underscore-ident-matcher.stderr
index b0e4d88f671..a663f34cde1 100644
--- a/tests/ui/underscore-ident-matcher.stderr
+++ b/tests/ui/underscore-ident-matcher.stderr
@@ -13,5 +13,5 @@ note: while trying to match meta-variable `$i:ident`
 LL |     ($i: ident) => (
    |      ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/underscore-imports/shadow.stderr b/tests/ui/underscore-imports/shadow.stderr
index f2c19405bbb..da263163892 100644
--- a/tests/ui/underscore-imports/shadow.stderr
+++ b/tests/ui/underscore-imports/shadow.stderr
@@ -10,6 +10,6 @@ help: the following trait is implemented but not in scope; perhaps add a `use` f
 LL +     use std::ops::Deref;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/underscore-lifetime/dyn-trait-underscore-in-struct.stderr b/tests/ui/underscore-lifetime/dyn-trait-underscore-in-struct.stderr
index fd086002803..e2bd9192d57 100644
--- a/tests/ui/underscore-lifetime/dyn-trait-underscore-in-struct.stderr
+++ b/tests/ui/underscore-lifetime/dyn-trait-underscore-in-struct.stderr
@@ -10,6 +10,6 @@ LL ~ struct Foo<'a> {
 LL ~     x: Box<dyn Debug + 'a>,
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/underscore-lifetime/dyn-trait-underscore.stderr b/tests/ui/underscore-lifetime/dyn-trait-underscore.stderr
index 60b0b3ee7ba..c3bda45e929 100644
--- a/tests/ui/underscore-lifetime/dyn-trait-underscore.stderr
+++ b/tests/ui/underscore-lifetime/dyn-trait-underscore.stderr
@@ -12,5 +12,5 @@ help: to declare that the trait object captures data from argument `items`, you
 LL | fn a<T>(items: &[T]) -> Box<dyn Iterator<Item=&T> + '_> {
    |                                                   ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/underscore-lifetime/in-fn-return-illegal.stderr b/tests/ui/underscore-lifetime/in-fn-return-illegal.stderr
index 6a104e8f94b..fb036c695b4 100644
--- a/tests/ui/underscore-lifetime/in-fn-return-illegal.stderr
+++ b/tests/ui/underscore-lifetime/in-fn-return-illegal.stderr
@@ -10,6 +10,6 @@ help: consider introducing a named lifetime parameter
 LL | fn foo<'a>(x: &'a u32, y: &'a u32) -> &'a u32 { loop { } }
    |       ++++     ++          ++          ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/underscore-lifetime/underscore-lifetime-elison-mismatch.stderr b/tests/ui/underscore-lifetime/underscore-lifetime-elison-mismatch.stderr
index 2b34f0c555a..ed9d22d2558 100644
--- a/tests/ui/underscore-lifetime/underscore-lifetime-elison-mismatch.stderr
+++ b/tests/ui/underscore-lifetime/underscore-lifetime-elison-mismatch.stderr
@@ -12,5 +12,5 @@ help: consider introducing a named lifetime parameter
 LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
    |       ++++              ~~          ~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/underscore-lifetime/underscore-outlives-bounds.stderr b/tests/ui/underscore-lifetime/underscore-outlives-bounds.stderr
index 4b38a26f957..4d23abf83da 100644
--- a/tests/ui/underscore-lifetime/underscore-outlives-bounds.stderr
+++ b/tests/ui/underscore-lifetime/underscore-outlives-bounds.stderr
@@ -4,6 +4,6 @@ error[E0637]: `'_` cannot be used here
 LL | impl<'b: '_> Foo<'b> for i32 {}
    |          ^^ `'_` is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2015.stderr b/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2015.stderr
index 3e197dc9a9d..54e62f34fba 100644
--- a/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2015.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2015.stderr
@@ -9,6 +9,6 @@ help: consider introducing a higher-ranked lifetime here
 LL |     T: for<'a> WithType<&'a u32>
    |        +++++++           ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2018.stderr b/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2018.stderr
index 08b4268e5d2..36f3e9ef145 100644
--- a/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2018.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-inherent-impl-ampersand-rust2018.stderr
@@ -9,6 +9,6 @@ help: consider introducing a higher-ranked lifetime here
 LL |     T: for<'a> WithType<&'a u32>
    |        +++++++           ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2015.stderr b/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2015.stderr
index 95939fd6b7e..d65c6042e16 100644
--- a/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2015.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2015.stderr
@@ -4,6 +4,6 @@ error[E0637]: `'_` cannot be used here
 LL |     T: WithRegion<'_>
    |                   ^^ `'_` is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2018.stderr b/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2018.stderr
index 95939fd6b7e..d65c6042e16 100644
--- a/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2018.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-inherent-impl-underscore.rust2018.stderr
@@ -4,6 +4,6 @@ error[E0637]: `'_` cannot be used here
 LL |     T: WithRegion<'_>
    |                   ^^ `'_` is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2015.stderr b/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2015.stderr
index 8c5bbb631b4..92b7a9c2af8 100644
--- a/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2015.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2015.stderr
@@ -9,6 +9,6 @@ help: consider introducing a higher-ranked lifetime here
 LL |     T: for<'a> WithType<&'a u32>
    |        +++++++           ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2018.stderr b/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2018.stderr
index 0268c59fa4a..63d8b99ed18 100644
--- a/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2018.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-trait-impl-region-2018.stderr
@@ -9,6 +9,6 @@ help: consider introducing a higher-ranked lifetime here
 LL |     T: for<'a> WithType<&'a u32>
    |        +++++++           ++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2015.stderr b/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2015.stderr
index 92caff0dcde..dae9523975d 100644
--- a/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2015.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2015.stderr
@@ -4,6 +4,6 @@ error[E0637]: `'_` cannot be used here
 LL |     T: WithRegion<'_>
    |                   ^^ `'_` is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2018.stderr b/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2018.stderr
index 92caff0dcde..dae9523975d 100644
--- a/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2018.stderr
+++ b/tests/ui/underscore-lifetime/where-clause-trait-impl-underscore.rust2018.stderr
@@ -4,6 +4,6 @@ error[E0637]: `'_` cannot be used here
 LL |     T: WithRegion<'_>
    |                   ^^ `'_` is a reserved lifetime name
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0637`.
diff --git a/tests/ui/unevaluated_fixed_size_array_len.stderr b/tests/ui/unevaluated_fixed_size_array_len.stderr
index b04a7b7f2f1..43cc377006e 100644
--- a/tests/ui/unevaluated_fixed_size_array_len.stderr
+++ b/tests/ui/unevaluated_fixed_size_array_len.stderr
@@ -6,6 +6,6 @@ LL |     <[(); 0] as Foo>::foo()
    |
    = help: the trait `Foo` is implemented for `[(); 1]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/uninhabited/privately-uninhabited-mir-call.stderr b/tests/ui/uninhabited/privately-uninhabited-mir-call.stderr
index 0dfd22a30ac..5f2f02c99fb 100644
--- a/tests/ui/uninhabited/privately-uninhabited-mir-call.stderr
+++ b/tests/ui/uninhabited/privately-uninhabited-mir-call.stderr
@@ -12,6 +12,6 @@ help: consider assigning a value
 LL |     let y: &mut u32 = todo!();
    |                     +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/uninhabited/uninhabited-irrefutable.stderr b/tests/ui/uninhabited/uninhabited-irrefutable.stderr
index daf75f51b5a..304e738ed25 100644
--- a/tests/ui/uninhabited/uninhabited-irrefutable.stderr
+++ b/tests/ui/uninhabited/uninhabited-irrefutable.stderr
@@ -21,6 +21,6 @@ help: you might want to use `let else` to handle the variant that isn't matched
 LL |     let Foo::D(_y, _z) = x else { todo!() };
    |                            ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0005`.
diff --git a/tests/ui/union/issue-41073.stderr b/tests/ui/union/issue-41073.stderr
index ae1c4dfed9a..c9b6903b1bf 100644
--- a/tests/ui/union/issue-41073.stderr
+++ b/tests/ui/union/issue-41073.stderr
@@ -10,6 +10,6 @@ help: wrap the field type in `ManuallyDrop<...>`
 LL |     a: std::mem::ManuallyDrop<A>,
    |        +++++++++++++++++++++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0740`.
diff --git a/tests/ui/union/projection-as-union-type-error-2.stderr b/tests/ui/union/projection-as-union-type-error-2.stderr
index 21f4ea103ad..3b073ca1fb4 100644
--- a/tests/ui/union/projection-as-union-type-error-2.stderr
+++ b/tests/ui/union/projection-as-union-type-error-2.stderr
@@ -17,6 +17,6 @@ LL | impl<T: NotImplemented> Identity for T {
    |         |
    |         unsatisfied trait bound introduced here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/union/projection-as-union-type-error.stderr b/tests/ui/union/projection-as-union-type-error.stderr
index 2b0241caf98..f43fb2fe9e5 100644
--- a/tests/ui/union/projection-as-union-type-error.stderr
+++ b/tests/ui/union/projection-as-union-type-error.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | pub trait Identity {
    | ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/union/union-const-pat.stderr b/tests/ui/union/union-const-pat.stderr
index dc87f4de521..e9dbb275944 100644
--- a/tests/ui/union/union-const-pat.stderr
+++ b/tests/ui/union/union-const-pat.stderr
@@ -4,5 +4,5 @@ error: cannot use unions in constant patterns
 LL |         C => {}
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/union/union-copy.stderr b/tests/ui/union/union-copy.stderr
index ff6fa48db90..bd63908b49a 100644
--- a/tests/ui/union/union-copy.stderr
+++ b/tests/ui/union/union-copy.stderr
@@ -13,6 +13,6 @@ note: the `Copy` impl for `ManuallyDrop<String>` requires that `String: Copy`
 LL |     a: std::mem::ManuallyDrop<String>
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/union/union-derive-eq.mirunsafeck.stderr b/tests/ui/union/union-derive-eq.mirunsafeck.stderr
index 136cd883e26..86e7c955d2e 100644
--- a/tests/ui/union/union-derive-eq.mirunsafeck.stderr
+++ b/tests/ui/union/union-derive-eq.mirunsafeck.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Eq)]
 LL | struct PartialEqNotEq;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/union/union-derive-eq.thirunsafeck.stderr b/tests/ui/union/union-derive-eq.thirunsafeck.stderr
index 136cd883e26..86e7c955d2e 100644
--- a/tests/ui/union/union-derive-eq.thirunsafeck.stderr
+++ b/tests/ui/union/union-derive-eq.thirunsafeck.stderr
@@ -16,6 +16,6 @@ LL + #[derive(Eq)]
 LL | struct PartialEqNotEq;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/union/union-empty.stderr b/tests/ui/union/union-empty.stderr
index a80b27e6eb5..03a939769c7 100644
--- a/tests/ui/union/union-empty.stderr
+++ b/tests/ui/union/union-empty.stderr
@@ -4,5 +4,5 @@ error: unions cannot have zero fields
 LL | union U {}
    | ^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/union/union-lint-dead-code.mirunsafeck.stderr b/tests/ui/union/union-lint-dead-code.mirunsafeck.stderr
index 6e21584c37c..8a3677d525d 100644
--- a/tests/ui/union/union-lint-dead-code.mirunsafeck.stderr
+++ b/tests/ui/union/union-lint-dead-code.mirunsafeck.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/union/union-lint-dead-code.thirunsafeck.stderr b/tests/ui/union/union-lint-dead-code.thirunsafeck.stderr
index 6e21584c37c..8a3677d525d 100644
--- a/tests/ui/union/union-lint-dead-code.thirunsafeck.stderr
+++ b/tests/ui/union/union-lint-dead-code.thirunsafeck.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(dead_code)]
    |         ^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/union/union-nonrepresentable.stderr b/tests/ui/union/union-nonrepresentable.stderr
index c266d2e9e13..90d38727f22 100644
--- a/tests/ui/union/union-nonrepresentable.stderr
+++ b/tests/ui/union/union-nonrepresentable.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     b: std::mem::ManuallyDrop<Box<U>>,
    |                               ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/union/union-repr-c.stderr b/tests/ui/union/union-repr-c.stderr
index 49124eee5ee..0beb7c376f3 100644
--- a/tests/ui/union/union-repr-c.stderr
+++ b/tests/ui/union/union-repr-c.stderr
@@ -17,5 +17,5 @@ note: the lint level is defined here
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/union/unresolved-field-isnt-copy.stderr b/tests/ui/union/unresolved-field-isnt-copy.stderr
index 22301582eef..ee5d1e37b14 100644
--- a/tests/ui/union/unresolved-field-isnt-copy.stderr
+++ b/tests/ui/union/unresolved-field-isnt-copy.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `Missing` in this scope
 LL |     x: *const Missing,
    |               ^^^^^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/unknown-language-item.stderr b/tests/ui/unknown-language-item.stderr
index c5fe9b8ad0e..1e0256867c5 100644
--- a/tests/ui/unknown-language-item.stderr
+++ b/tests/ui/unknown-language-item.stderr
@@ -4,6 +4,6 @@ error[E0522]: definition of an unknown language item: `foo`
 LL | #[lang = "foo"]
    | ^^^^^^^^^^^^^^^ definition of unknown language item `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0522`.
diff --git a/tests/ui/unknown-tool-name.stderr b/tests/ui/unknown-tool-name.stderr
index 4a1370ba80a..361d359a10e 100644
--- a/tests/ui/unknown-tool-name.stderr
+++ b/tests/ui/unknown-tool-name.stderr
@@ -4,6 +4,6 @@ error[E0433]: failed to resolve: use of undeclared crate or module `foo`
 LL | #[foo::bar]
    |   ^^^ use of undeclared crate or module `foo`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/unop-neg-bool.stderr b/tests/ui/unop-neg-bool.stderr
index 9913747b88e..9bc5e7dcf22 100644
--- a/tests/ui/unop-neg-bool.stderr
+++ b/tests/ui/unop-neg-bool.stderr
@@ -4,6 +4,6 @@ error[E0600]: cannot apply unary operator `-` to type `bool`
 LL |     -true;
    |     ^^^^^ cannot apply unary operator `-`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/unpretty/avoid-crash.stderr b/tests/ui/unpretty/avoid-crash.stderr
index 15bcc277e64..6fa3e8ca630 100644
--- a/tests/ui/unpretty/avoid-crash.stderr
+++ b/tests/ui/unpretty/avoid-crash.stderr
@@ -1,4 +1,4 @@
 error: failed to write `/tmp/` due to $ERROR_MESSAGE
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/unpretty/bad-literal.stderr b/tests/ui/unpretty/bad-literal.stderr
index f3fcb4a4e92..b6259484f67 100644
--- a/tests/ui/unpretty/bad-literal.stderr
+++ b/tests/ui/unpretty/bad-literal.stderr
@@ -6,5 +6,5 @@ LL |     1u;
    |
    = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/unpretty/mir-unpretty.stderr b/tests/ui/unpretty/mir-unpretty.stderr
index 3808f8583b8..a9e40884bfb 100644
--- a/tests/ui/unpretty/mir-unpretty.stderr
+++ b/tests/ui/unpretty/mir-unpretty.stderr
@@ -6,6 +6,6 @@ LL |     let x: () = 0;
    |            |
    |            expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unresolved/unresolved-asterisk-imports.stderr b/tests/ui/unresolved/unresolved-asterisk-imports.stderr
index 8df8eab34a7..24ac2f8e621 100644
--- a/tests/ui/unresolved/unresolved-asterisk-imports.stderr
+++ b/tests/ui/unresolved/unresolved-asterisk-imports.stderr
@@ -6,6 +6,6 @@ LL | use not_existing_crate::*;
    |
    = help: consider adding `extern crate not_existing_crate` to use the `not_existing_crate` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/unresolved/unresolved-extern-mod-suggestion.stderr b/tests/ui/unresolved/unresolved-extern-mod-suggestion.stderr
index 28333228a29..b493d0fa3fe 100644
--- a/tests/ui/unresolved/unresolved-extern-mod-suggestion.stderr
+++ b/tests/ui/unresolved/unresolved-extern-mod-suggestion.stderr
@@ -8,6 +8,6 @@ LL | use core;
    |
    = note: `core` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0254`.
diff --git a/tests/ui/unresolved/unresolved-import-recovery.stderr b/tests/ui/unresolved/unresolved-import-recovery.stderr
index 5e371b70bfa..1c006049756 100644
--- a/tests/ui/unresolved/unresolved-import-recovery.stderr
+++ b/tests/ui/unresolved/unresolved-import-recovery.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `unresolved`
 LL |     pub use unresolved;
    |             ^^^^^^^^^^ no `unresolved` in the root
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/unresolved/unresolved-import-suggest-disambiguated-crate-name.stderr b/tests/ui/unresolved/unresolved-import-suggest-disambiguated-crate-name.stderr
index f139c0f3cf1..c6812dbb196 100644
--- a/tests/ui/unresolved/unresolved-import-suggest-disambiguated-crate-name.stderr
+++ b/tests/ui/unresolved/unresolved-import-suggest-disambiguated-crate-name.stderr
@@ -9,6 +9,6 @@ help: consider importing this struct instead
 LL | pub use ::library::SomeUsefulType;
    |         ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/unsafe/foreign-unsafe-fn-called.mir.stderr b/tests/ui/unsafe/foreign-unsafe-fn-called.mir.stderr
index d3cf5d84fdd..5157dbb514b 100644
--- a/tests/ui/unsafe/foreign-unsafe-fn-called.mir.stderr
+++ b/tests/ui/unsafe/foreign-unsafe-fn-called.mir.stderr
@@ -6,6 +6,6 @@ LL |     test::free();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/foreign-unsafe-fn-called.thir.stderr b/tests/ui/unsafe/foreign-unsafe-fn-called.thir.stderr
index 00ba0f7a6a3..8c221314cd7 100644
--- a/tests/ui/unsafe/foreign-unsafe-fn-called.thir.stderr
+++ b/tests/ui/unsafe/foreign-unsafe-fn-called.thir.stderr
@@ -6,6 +6,6 @@ LL |     test::free();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/initializing-ranged-via-ctor.stderr b/tests/ui/unsafe/initializing-ranged-via-ctor.stderr
index 13438fd31d0..56b112867cf 100644
--- a/tests/ui/unsafe/initializing-ranged-via-ctor.stderr
+++ b/tests/ui/unsafe/initializing-ranged-via-ctor.stderr
@@ -11,6 +11,6 @@ LL |     println!("{:?}", Some(1).map(NonZeroAndOneU8).unwrap());
 note: required by a bound in `Option::<T>::map`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsafe/inline_asm.mir.stderr b/tests/ui/unsafe/inline_asm.mir.stderr
index 633f1edb26c..e38a9388a78 100644
--- a/tests/ui/unsafe/inline_asm.mir.stderr
+++ b/tests/ui/unsafe/inline_asm.mir.stderr
@@ -6,6 +6,6 @@ LL |     asm!("nop");
    |
    = note: inline assembly is entirely unchecked and can cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/inline_asm.thir.stderr b/tests/ui/unsafe/inline_asm.thir.stderr
index 633f1edb26c..e38a9388a78 100644
--- a/tests/ui/unsafe/inline_asm.thir.stderr
+++ b/tests/ui/unsafe/inline_asm.thir.stderr
@@ -6,6 +6,6 @@ LL |     asm!("nop");
    |
    = note: inline assembly is entirely unchecked and can cause undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/issue-115348-false-positive-warning-of-unnecessary-unsafe.stderr b/tests/ui/unsafe/issue-115348-false-positive-warning-of-unnecessary-unsafe.stderr
index 7384899b978..9dd68d2a634 100644
--- a/tests/ui/unsafe/issue-115348-false-positive-warning-of-unnecessary-unsafe.stderr
+++ b/tests/ui/unsafe/issue-115348-false-positive-warning-of-unnecessary-unsafe.stderr
@@ -16,6 +16,6 @@ LL ~         Some(_) => unsafe { uwu() },
 LL ~         None => todo!(),
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/unsafe/issue-3080.mir.stderr b/tests/ui/unsafe/issue-3080.mir.stderr
index f395c30b815..a1ad98d205e 100644
--- a/tests/ui/unsafe/issue-3080.mir.stderr
+++ b/tests/ui/unsafe/issue-3080.mir.stderr
@@ -6,6 +6,6 @@ LL |     X(()).with();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/issue-3080.thir.stderr b/tests/ui/unsafe/issue-3080.thir.stderr
index 4d8acac61d9..1018218b1b0 100644
--- a/tests/ui/unsafe/issue-3080.thir.stderr
+++ b/tests/ui/unsafe/issue-3080.thir.stderr
@@ -6,6 +6,6 @@ LL |     X(()).with();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr b/tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr
index 660c4070451..23bfe3c9c2e 100644
--- a/tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr
+++ b/tests/ui/unsafe/ranged-ctor-as-fn-ptr.stderr
@@ -10,6 +10,6 @@ LL |     let x: fn(u8) -> NonZeroAndOneU8 = NonZeroAndOneU8;
            found struct constructor `unsafe fn(_) -> NonZeroAndOneU8 {NonZeroAndOneU8}`
    = note: unsafe functions cannot be coerced into safe function pointers
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unsafe/ranged_ints.mir.stderr b/tests/ui/unsafe/ranged_ints.mir.stderr
index f9ef7834e1e..ef00edae05d 100644
--- a/tests/ui/unsafe/ranged_ints.mir.stderr
+++ b/tests/ui/unsafe/ranged_ints.mir.stderr
@@ -6,6 +6,6 @@ LL |     let _x = NonZero(0);
    |
    = note: initializing a layout restricted type's field with a value outside the valid range is undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints.thir.stderr b/tests/ui/unsafe/ranged_ints.thir.stderr
index f9ef7834e1e..ef00edae05d 100644
--- a/tests/ui/unsafe/ranged_ints.thir.stderr
+++ b/tests/ui/unsafe/ranged_ints.thir.stderr
@@ -6,6 +6,6 @@ LL |     let _x = NonZero(0);
    |
    = note: initializing a layout restricted type's field with a value outside the valid range is undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints3.mirunsafeck.stderr b/tests/ui/unsafe/ranged_ints3.mirunsafeck.stderr
index 9eec0b09e9b..72bce5de0ae 100644
--- a/tests/ui/unsafe/ranged_ints3.mirunsafeck.stderr
+++ b/tests/ui/unsafe/ranged_ints3.mirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     let y = &x.0;
    |
    = note: references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints3.thirunsafeck.stderr b/tests/ui/unsafe/ranged_ints3.thirunsafeck.stderr
index 9eec0b09e9b..72bce5de0ae 100644
--- a/tests/ui/unsafe/ranged_ints3.thirunsafeck.stderr
+++ b/tests/ui/unsafe/ranged_ints3.thirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     let y = &x.0;
    |
    = note: references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints4.mirunsafeck.stderr b/tests/ui/unsafe/ranged_ints4.mirunsafeck.stderr
index 493483d2c45..4f2f1e42e76 100644
--- a/tests/ui/unsafe/ranged_ints4.mirunsafeck.stderr
+++ b/tests/ui/unsafe/ranged_ints4.mirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     x.0 = 0;
    |
    = note: mutating layout constrained fields cannot statically be checked for valid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints4.thirunsafeck.stderr b/tests/ui/unsafe/ranged_ints4.thirunsafeck.stderr
index 493483d2c45..4f2f1e42e76 100644
--- a/tests/ui/unsafe/ranged_ints4.thirunsafeck.stderr
+++ b/tests/ui/unsafe/ranged_ints4.thirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     x.0 = 0;
    |
    = note: mutating layout constrained fields cannot statically be checked for valid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints4_const.mirunsafeck.stderr b/tests/ui/unsafe/ranged_ints4_const.mirunsafeck.stderr
index a06c6f479b8..a2a3ae668a2 100644
--- a/tests/ui/unsafe/ranged_ints4_const.mirunsafeck.stderr
+++ b/tests/ui/unsafe/ranged_ints4_const.mirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     x.0 = 0;
    |
    = note: mutating layout constrained fields cannot statically be checked for valid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints4_const.thirunsafeck.stderr b/tests/ui/unsafe/ranged_ints4_const.thirunsafeck.stderr
index a06c6f479b8..a2a3ae668a2 100644
--- a/tests/ui/unsafe/ranged_ints4_const.thirunsafeck.stderr
+++ b/tests/ui/unsafe/ranged_ints4_const.thirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     x.0 = 0;
    |
    = note: mutating layout constrained fields cannot statically be checked for valid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints_const.mir.stderr b/tests/ui/unsafe/ranged_ints_const.mir.stderr
index 33d134c7ce5..563b9be2672 100644
--- a/tests/ui/unsafe/ranged_ints_const.mir.stderr
+++ b/tests/ui/unsafe/ranged_ints_const.mir.stderr
@@ -6,6 +6,6 @@ LL | const fn foo() -> NonZero<u32> { NonZero(0) }
    |
    = note: initializing a layout restricted type's field with a value outside the valid range is undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/ranged_ints_const.thir.stderr b/tests/ui/unsafe/ranged_ints_const.thir.stderr
index 33d134c7ce5..563b9be2672 100644
--- a/tests/ui/unsafe/ranged_ints_const.thir.stderr
+++ b/tests/ui/unsafe/ranged_ints_const.thir.stderr
@@ -6,6 +6,6 @@ LL | const fn foo() -> NonZero<u32> { NonZero(0) }
    |
    = note: initializing a layout restricted type's field with a value outside the valid range is undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-assign.mirunsafeck.stderr b/tests/ui/unsafe/unsafe-assign.mirunsafeck.stderr
index 9abc51424ab..f8b55e0668d 100644
--- a/tests/ui/unsafe/unsafe-assign.mirunsafeck.stderr
+++ b/tests/ui/unsafe/unsafe-assign.mirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     foo.0.0 = 0;
    |
    = note: mutating layout constrained fields cannot statically be checked for valid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-assign.thirunsafeck.stderr b/tests/ui/unsafe/unsafe-assign.thirunsafeck.stderr
index 9abc51424ab..f8b55e0668d 100644
--- a/tests/ui/unsafe/unsafe-assign.thirunsafeck.stderr
+++ b/tests/ui/unsafe/unsafe-assign.thirunsafeck.stderr
@@ -6,6 +6,6 @@ LL |     foo.0.0 = 0;
    |
    = note: mutating layout constrained fields cannot statically be checked for valid values
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-block-without-braces.stderr b/tests/ui/unsafe/unsafe-block-without-braces.stderr
index 44f77b99c56..d29e49d73a6 100644
--- a/tests/ui/unsafe/unsafe-block-without-braces.stderr
+++ b/tests/ui/unsafe/unsafe-block-without-braces.stderr
@@ -11,5 +11,5 @@ help: try placing this code inside a block
 LL |         { std::mem::transmute::<f32, u32>(1.0); }
    |         +                                       +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/unsafe/unsafe-const-fn.mir.stderr b/tests/ui/unsafe/unsafe-const-fn.mir.stderr
index 3031be720f0..2450f08664c 100644
--- a/tests/ui/unsafe/unsafe-const-fn.mir.stderr
+++ b/tests/ui/unsafe/unsafe-const-fn.mir.stderr
@@ -6,6 +6,6 @@ LL | const VAL: u32 = dummy(0xFFFF);
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-const-fn.thir.stderr b/tests/ui/unsafe/unsafe-const-fn.thir.stderr
index 1a77adf4459..199dca9237e 100644
--- a/tests/ui/unsafe/unsafe-const-fn.thir.stderr
+++ b/tests/ui/unsafe/unsafe-const-fn.thir.stderr
@@ -6,6 +6,6 @@ LL | const VAL: u32 = dummy(0xFFFF);
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.mir.stderr b/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.mir.stderr
index fee645e4118..da3d5f3bd29 100644
--- a/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.mir.stderr
+++ b/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.mir.stderr
@@ -6,6 +6,6 @@ LL |     *p = 0;
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.thir.stderr b/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.thir.stderr
index bbe4a415b5e..aa5644782a4 100644
--- a/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.thir.stderr
+++ b/tests/ui/unsafe/unsafe-fn-assign-deref-ptr.thir.stderr
@@ -6,6 +6,6 @@ LL |     *p = 0;
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-fn-autoderef.stderr b/tests/ui/unsafe/unsafe-fn-autoderef.stderr
index f563118e8ac..c3ab8020222 100644
--- a/tests/ui/unsafe/unsafe-fn-autoderef.stderr
+++ b/tests/ui/unsafe/unsafe-fn-autoderef.stderr
@@ -7,6 +7,6 @@ LL |     return p.f;
    |            | unknown field
    |            help: `p` is a raw pointer; try dereferencing it: `(*p).f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/unsafe/unsafe-fn-called-from-safe.mir.stderr b/tests/ui/unsafe/unsafe-fn-called-from-safe.mir.stderr
index 1d6fa4cbf40..d3347437075 100644
--- a/tests/ui/unsafe/unsafe-fn-called-from-safe.mir.stderr
+++ b/tests/ui/unsafe/unsafe-fn-called-from-safe.mir.stderr
@@ -6,6 +6,6 @@ LL |     f();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-fn-called-from-safe.thir.stderr b/tests/ui/unsafe/unsafe-fn-called-from-safe.thir.stderr
index 206dbd90a75..75431666186 100644
--- a/tests/ui/unsafe/unsafe-fn-called-from-safe.thir.stderr
+++ b/tests/ui/unsafe/unsafe-fn-called-from-safe.thir.stderr
@@ -6,6 +6,6 @@ LL |     f();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-fn-used-as-value.mir.stderr b/tests/ui/unsafe/unsafe-fn-used-as-value.mir.stderr
index b08a7109dda..01e8e49ecfa 100644
--- a/tests/ui/unsafe/unsafe-fn-used-as-value.mir.stderr
+++ b/tests/ui/unsafe/unsafe-fn-used-as-value.mir.stderr
@@ -6,6 +6,6 @@ LL |     x();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-fn-used-as-value.thir.stderr b/tests/ui/unsafe/unsafe-fn-used-as-value.thir.stderr
index e81dd3b2b41..c38da7226f6 100644
--- a/tests/ui/unsafe/unsafe-fn-used-as-value.thir.stderr
+++ b/tests/ui/unsafe/unsafe-fn-used-as-value.thir.stderr
@@ -6,6 +6,6 @@ LL |     x();
    |
    = note: consult the function's documentation for information on how to avoid undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-subtyping.stderr b/tests/ui/unsafe/unsafe-subtyping.stderr
index 2db7cc31280..1cc949cf757 100644
--- a/tests/ui/unsafe/unsafe-subtyping.stderr
+++ b/tests/ui/unsafe/unsafe-subtyping.stderr
@@ -9,6 +9,6 @@ LL |     x
    = note: expected enum `Option<unsafe fn(_)>`
               found enum `Option<fn(_)>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unsafe/unsafe-trait-impl.stderr b/tests/ui/unsafe/unsafe-trait-impl.stderr
index 18ba79404b7..db5200e1c20 100644
--- a/tests/ui/unsafe/unsafe-trait-impl.stderr
+++ b/tests/ui/unsafe/unsafe-trait-impl.stderr
@@ -12,6 +12,6 @@ LL |     unsafe fn len(&self) -> u32;
    = note: expected signature `unsafe fn(&u32) -> _`
               found signature `fn(&u32) -> _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/unsafe/unsafe-unstable-const-fn.mir.stderr b/tests/ui/unsafe/unsafe-unstable-const-fn.mir.stderr
index dcb84a80cb0..79133ab39a0 100644
--- a/tests/ui/unsafe/unsafe-unstable-const-fn.mir.stderr
+++ b/tests/ui/unsafe/unsafe-unstable-const-fn.mir.stderr
@@ -6,6 +6,6 @@ LL |     *a == b
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe-unstable-const-fn.thir.stderr b/tests/ui/unsafe/unsafe-unstable-const-fn.thir.stderr
index dcb84a80cb0..79133ab39a0 100644
--- a/tests/ui/unsafe/unsafe-unstable-const-fn.thir.stderr
+++ b/tests/ui/unsafe/unsafe-unstable-const-fn.thir.stderr
@@ -6,6 +6,6 @@ LL |     *a == b
    |
    = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsized-locals/by-value-trait-object-safety.stderr b/tests/ui/unsized-locals/by-value-trait-object-safety.stderr
index 4f13ec7ac08..6a93464febb 100644
--- a/tests/ui/unsized-locals/by-value-trait-object-safety.stderr
+++ b/tests/ui/unsized-locals/by-value-trait-object-safety.stderr
@@ -16,5 +16,5 @@ LL |         Self: Sized;
 LL |     x.foo();
    |       ^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/unsized-locals/issue-30276-feature-flagged.stderr b/tests/ui/unsized-locals/issue-30276-feature-flagged.stderr
index b6002cf895f..ee8e4f3eee2 100644
--- a/tests/ui/unsized-locals/issue-30276-feature-flagged.stderr
+++ b/tests/ui/unsized-locals/issue-30276-feature-flagged.stderr
@@ -17,6 +17,6 @@ LL |     let _x: fn(_) -> Test = Test;
    = note: all function arguments must have a statically known size
    = help: unsized fn params are gated as an unstable feature
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized-locals/issue-30276.stderr b/tests/ui/unsized-locals/issue-30276.stderr
index 8cccbd792da..15f70b18b32 100644
--- a/tests/ui/unsized-locals/issue-30276.stderr
+++ b/tests/ui/unsized-locals/issue-30276.stderr
@@ -8,6 +8,6 @@ LL |     let _x: fn(_) -> Test = Test;
    = note: all function arguments must have a statically known size
    = help: unsized fn params are gated as an unstable feature
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized-locals/issue-50940-with-feature.stderr b/tests/ui/unsized-locals/issue-50940-with-feature.stderr
index 8bbe317ec74..b39eb2e70bb 100644
--- a/tests/ui/unsized-locals/issue-50940-with-feature.stderr
+++ b/tests/ui/unsized-locals/issue-50940-with-feature.stderr
@@ -21,6 +21,6 @@ LL |     struct A<X: ?Sized>(X);
    |            ^
    = note: the return type of a function must have a statically known size
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized-locals/issue-50940.stderr b/tests/ui/unsized-locals/issue-50940.stderr
index 8f09b460e00..160e14794d5 100644
--- a/tests/ui/unsized-locals/issue-50940.stderr
+++ b/tests/ui/unsized-locals/issue-50940.stderr
@@ -8,6 +8,6 @@ LL |     A as fn(str) -> A<str>;
    = note: all function arguments must have a statically known size
    = help: unsized fn params are gated as an unstable feature
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized-locals/issue-67981.stderr b/tests/ui/unsized-locals/issue-67981.stderr
index 13fdc037ac5..e1fa41de2a8 100644
--- a/tests/ui/unsized-locals/issue-67981.stderr
+++ b/tests/ui/unsized-locals/issue-67981.stderr
@@ -7,6 +7,6 @@ LL |     let f: fn([u8]) = |_| {};
    = help: the trait `Sized` is not implemented for `[u8]`
    = note: all function arguments must have a statically known size
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized-locals/rust-call.stderr b/tests/ui/unsized-locals/rust-call.stderr
index fff7ef75b33..9eb0f3dabcc 100644
--- a/tests/ui/unsized-locals/rust-call.stderr
+++ b/tests/ui/unsized-locals/rust-call.stderr
@@ -8,6 +8,6 @@ LL |     f(*slice);
    = note: required because it appears within the type `([u8],)`
    = note: argument required to be sized due to `extern "rust-call"` ABI
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized-locals/unsized-exprs2.stderr b/tests/ui/unsized-locals/unsized-exprs2.stderr
index 88269f237af..47b6d72acc7 100644
--- a/tests/ui/unsized-locals/unsized-exprs2.stderr
+++ b/tests/ui/unsized-locals/unsized-exprs2.stderr
@@ -7,6 +7,6 @@ LL |     udrop::<[u8]>(foo()[..]);
    |     cannot move out of here
    |     move occurs because value has type `[u8]`, which does not implement the `Copy` trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/unsized-locals/unsized-exprs3.stderr b/tests/ui/unsized-locals/unsized-exprs3.stderr
index 57d9978225a..9dfedfd8ada 100644
--- a/tests/ui/unsized-locals/unsized-exprs3.stderr
+++ b/tests/ui/unsized-locals/unsized-exprs3.stderr
@@ -8,6 +8,6 @@ LL |     udrop as fn([u8]);
    = note: all function arguments must have a statically known size
    = help: unsized fn params are gated as an unstable feature
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/box-instead-of-dyn-fn.stderr b/tests/ui/unsized/box-instead-of-dyn-fn.stderr
index 6087f5c5465..f2828b384b2 100644
--- a/tests/ui/unsized/box-instead-of-dyn-fn.stderr
+++ b/tests/ui/unsized/box-instead-of-dyn-fn.stderr
@@ -16,6 +16,6 @@ LL |     if a % 2 == 0 {
 LL ~         Box::new(move || println!("{a}"))
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0746`.
diff --git a/tests/ui/unsized/issue-30355.stderr b/tests/ui/unsized/issue-30355.stderr
index 71bbdf5dec7..cfbcd0aea90 100644
--- a/tests/ui/unsized/issue-30355.stderr
+++ b/tests/ui/unsized/issue-30355.stderr
@@ -8,6 +8,6 @@ LL |     &X(*Y)
    = note: all function arguments must have a statically known size
    = help: unsized fn params are gated as an unstable feature
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/issue-71659.current.stderr b/tests/ui/unsized/issue-71659.current.stderr
index 6b982a73952..df0b998fd88 100644
--- a/tests/ui/unsized/issue-71659.current.stderr
+++ b/tests/ui/unsized/issue-71659.current.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Self: CastTo<T>,
    |               ^^^^^^^^^ required by this bound in `Cast::cast`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/issue-71659.next.stderr b/tests/ui/unsized/issue-71659.next.stderr
index 6b982a73952..df0b998fd88 100644
--- a/tests/ui/unsized/issue-71659.next.stderr
+++ b/tests/ui/unsized/issue-71659.next.stderr
@@ -13,6 +13,6 @@ LL |     where
 LL |         Self: CastTo<T>,
    |               ^^^^^^^^^ required by this bound in `Cast::cast`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/issue-75707.stderr b/tests/ui/unsized/issue-75707.stderr
index aa7f9c78fa8..f5f2f7192aa 100644
--- a/tests/ui/unsized/issue-75707.stderr
+++ b/tests/ui/unsized/issue-75707.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `f`
 LL | fn f<P: Processing + ?Sized>() {
    |         ^^^^^^^^^^ required by this bound in `f`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/issue-91801.stderr b/tests/ui/unsized/issue-91801.stderr
index da5c4322403..d1d652d1860 100644
--- a/tests/ui/unsized/issue-91801.stderr
+++ b/tests/ui/unsized/issue-91801.stderr
@@ -9,6 +9,6 @@ help: box the return type, and wrap all of the returned values in `Box::new`
 LL | fn or<'a>(first: &'static Validator<'a>, second: &'static Validator<'a>) -> Box<Validator<'a>> {
    |                                                                             ++++             +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0746`.
diff --git a/tests/ui/unsized/issue-91803.stderr b/tests/ui/unsized/issue-91803.stderr
index a43b8d0741f..632af02b4b6 100644
--- a/tests/ui/unsized/issue-91803.stderr
+++ b/tests/ui/unsized/issue-91803.stderr
@@ -13,6 +13,6 @@ help: box the return type, and wrap all of the returned values in `Box::new`
 LL | fn or<'a>(first: &'static dyn Foo<'a>) -> Box<dyn Foo<'a>> {
    |                                           ++++           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0746`.
diff --git a/tests/ui/unsized/param-mentioned-by-different-field.stderr b/tests/ui/unsized/param-mentioned-by-different-field.stderr
index b1ad0cb5b88..0d8b59aa922 100644
--- a/tests/ui/unsized/param-mentioned-by-different-field.stderr
+++ b/tests/ui/unsized/param-mentioned-by-different-field.stderr
@@ -9,6 +9,6 @@ LL |     let y: &Foo<[u8]> = &x;
    = note: expected reference `&Foo<[u8]>`
               found reference `&Foo<[u8; 1]>`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unsized/return-unsized-from-trait-method.stderr b/tests/ui/unsized/return-unsized-from-trait-method.stderr
index 671d409937c..82446151a7e 100644
--- a/tests/ui/unsized/return-unsized-from-trait-method.stderr
+++ b/tests/ui/unsized/return-unsized-from-trait-method.stderr
@@ -4,6 +4,6 @@ error[E0161]: cannot move a value of type `[u8]`
 LL |         let _ = f.foo();
    |                 ^^^^^^^ the size of `[u8]` cannot be statically determined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0161`.
diff --git a/tests/ui/unsized/unsized-bare-typaram.stderr b/tests/ui/unsized/unsized-bare-typaram.stderr
index daef984404a..aa3f8fae72a 100644
--- a/tests/ui/unsized/unsized-bare-typaram.stderr
+++ b/tests/ui/unsized/unsized-bare-typaram.stderr
@@ -17,6 +17,6 @@ LL - fn foo<T: ?Sized>() { bar::<T>() }
 LL + fn foo<T>() { bar::<T>() }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/unsized-enum.stderr b/tests/ui/unsized/unsized-enum.stderr
index 9e6408e8143..8c56a83a512 100644
--- a/tests/ui/unsized/unsized-enum.stderr
+++ b/tests/ui/unsized/unsized-enum.stderr
@@ -24,6 +24,6 @@ LL - fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
 LL + fn foo2<T>() { not_sized::<Foo<T>>() }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/unsized-fn-arg.stderr b/tests/ui/unsized/unsized-fn-arg.stderr
index 0f6fadde19a..c8a6622b809 100644
--- a/tests/ui/unsized/unsized-fn-arg.stderr
+++ b/tests/ui/unsized/unsized-fn-arg.stderr
@@ -17,6 +17,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn f<T: ?Sized>(t: &T) {}
    |                    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unsized/unsized-inherent-impl-self-type.stderr b/tests/ui/unsized/unsized-inherent-impl-self-type.stderr
index 9e5ad92eb04..3e16a20d726 100644
--- a/tests/ui/unsized/unsized-inherent-impl-self-type.stderr
+++ b/tests/ui/unsized/unsized-inherent-impl-self-type.stderr
@@ -24,6 +24,6 @@ LL - impl<X: ?Sized> S5<X> {
 LL + impl<X> S5<X> {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/unused-crate-deps/deny-attr.stderr b/tests/ui/unused-crate-deps/deny-attr.stderr
index 93694f6827f..89e87c9d5ac 100644
--- a/tests/ui/unused-crate-deps/deny-attr.stderr
+++ b/tests/ui/unused-crate-deps/deny-attr.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(unused_crate_dependencies)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/unused-crate-deps/deny-cmdline.stderr b/tests/ui/unused-crate-deps/deny-cmdline.stderr
index 0951dc670fe..fc526878ef0 100644
--- a/tests/ui/unused-crate-deps/deny-cmdline.stderr
+++ b/tests/ui/unused-crate-deps/deny-cmdline.stderr
@@ -6,5 +6,5 @@ LL | fn main() {}
    |
    = note: requested on the command line with `-D unused-crate-dependencies`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/use/issue-18986.stderr b/tests/ui/use/issue-18986.stderr
index 6c23178c700..350cb18f952 100644
--- a/tests/ui/use/issue-18986.stderr
+++ b/tests/ui/use/issue-18986.stderr
@@ -4,6 +4,6 @@ error[E0574]: expected struct, variant or union type, found trait `Trait`
 LL |         Trait { x: 42 } => ()
    |         ^^^^^ not a struct, variant or union type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0574`.
diff --git a/tests/ui/use/use-after-move-based-on-type.stderr b/tests/ui/use/use-after-move-based-on-type.stderr
index 7b4d2454994..02a6ed599a9 100644
--- a/tests/ui/use/use-after-move-based-on-type.stderr
+++ b/tests/ui/use/use-after-move-based-on-type.stderr
@@ -14,6 +14,6 @@ help: consider cloning the value if the performance cost is acceptable
 LL |     let _y = x.clone();
    |               ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/use/use-after-move-implicity-coerced-object.stderr b/tests/ui/use/use-after-move-implicity-coerced-object.stderr
index 84487a8d0dc..35ede21717e 100644
--- a/tests/ui/use/use-after-move-implicity-coerced-object.stderr
+++ b/tests/ui/use/use-after-move-implicity-coerced-object.stderr
@@ -18,6 +18,6 @@ LL |     fn push(&mut self, n: Box<dyn ToString + 'static>) {
    |        |
    |        in this method
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/use/use-after-move-self-based-on-type.stderr b/tests/ui/use/use-after-move-self-based-on-type.stderr
index 1bdf49801f9..17827beccce 100644
--- a/tests/ui/use/use-after-move-self-based-on-type.stderr
+++ b/tests/ui/use/use-after-move-self-based-on-type.stderr
@@ -14,6 +14,6 @@ note: `S::bar` takes ownership of the receiver `self`, which moves `self`
 LL |     pub fn bar(self) {}
    |                ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/use/use-after-move-self.stderr b/tests/ui/use/use-after-move-self.stderr
index 59cc22eadb0..ebd6cef58b4 100644
--- a/tests/ui/use/use-after-move-self.stderr
+++ b/tests/ui/use/use-after-move-self.stderr
@@ -14,6 +14,6 @@ note: `S::bar` takes ownership of the receiver `self`, which moves `self`
 LL |     pub fn bar(self) {}
    |                ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/use/use-associated-const.stderr b/tests/ui/use/use-associated-const.stderr
index 4bc0d7e61cb..f0de7a7466c 100644
--- a/tests/ui/use/use-associated-const.stderr
+++ b/tests/ui/use/use-associated-const.stderr
@@ -4,6 +4,6 @@ error[E0432]: unresolved import `foo::Foo`
 LL | use foo::Foo::BAR;
    |          ^^^ `Foo` is a struct, not a module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/use/use-crate-self.stderr b/tests/ui/use/use-crate-self.stderr
index dd4036bfff4..a8f65b128fe 100644
--- a/tests/ui/use/use-crate-self.stderr
+++ b/tests/ui/use/use-crate-self.stderr
@@ -4,5 +4,5 @@ error: crate root imports need to be explicitly named: `use crate as name;`
 LL | use crate::{self};
    |             ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/use/use-meta-mismatch.stderr b/tests/ui/use/use-meta-mismatch.stderr
index 62b71fe8e12..b793229e5fd 100644
--- a/tests/ui/use/use-meta-mismatch.stderr
+++ b/tests/ui/use/use-meta-mismatch.stderr
@@ -4,6 +4,6 @@ error[E0463]: can't find crate for `fake_crate`
 LL | extern crate fake_crate as extra;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't find crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0463`.
diff --git a/tests/ui/use/use-mod/use-mod-5.stderr b/tests/ui/use/use-mod/use-mod-5.stderr
index 62859e261a3..22201361c58 100644
--- a/tests/ui/use/use-mod/use-mod-5.stderr
+++ b/tests/ui/use/use-mod/use-mod-5.stderr
@@ -14,6 +14,6 @@ help: alternatively, use the multi-path `use` syntax to import `self`
 LL | use foo::bar::{self};
    |               +    +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0429`.
diff --git a/tests/ui/use/use-mod/use-mod-6.stderr b/tests/ui/use/use-mod/use-mod-6.stderr
index 2d2c90067aa..f9ab346f8c3 100644
--- a/tests/ui/use/use-mod/use-mod-6.stderr
+++ b/tests/ui/use/use-mod/use-mod-6.stderr
@@ -14,6 +14,6 @@ help: alternatively, use the multi-path `use` syntax to import `self`
 LL | use foo::bar::{self as abc};
    |               +           +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0429`.
diff --git a/tests/ui/use/use-nested-groups-error.stderr b/tests/ui/use/use-nested-groups-error.stderr
index 7234c8ec621..d73754c6baa 100644
--- a/tests/ui/use/use-nested-groups-error.stderr
+++ b/tests/ui/use/use-nested-groups-error.stderr
@@ -7,6 +7,6 @@ LL | use a::{b1::{C1, C2}, B2};
    |              no `C1` in `a::b1`
    |              help: a similar name exists in the module: `C2`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/use/use-paths-as-items.stderr b/tests/ui/use/use-paths-as-items.stderr
index b09001a9bcd..c54f40dafbc 100644
--- a/tests/ui/use/use-paths-as-items.stderr
+++ b/tests/ui/use/use-paths-as-items.stderr
@@ -8,6 +8,6 @@ LL | use std::mem;
    |
    = note: `mem` must be defined only once in the type namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0252`.
diff --git a/tests/ui/usize-generic-argument-parent.stderr b/tests/ui/usize-generic-argument-parent.stderr
index 131c476aa55..9c081a287ed 100644
--- a/tests/ui/usize-generic-argument-parent.stderr
+++ b/tests/ui/usize-generic-argument-parent.stderr
@@ -12,6 +12,6 @@ LL -     let x: usize<foo>;
 LL +     let x: usize;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/variance/variance-associated-consts.stderr b/tests/ui/variance/variance-associated-consts.stderr
index 4df2d8da3d6..e25f0879add 100644
--- a/tests/ui/variance/variance-associated-consts.stderr
+++ b/tests/ui/variance/variance-associated-consts.stderr
@@ -4,5 +4,5 @@ error: [o]
 LL | struct Foo<T: Trait> {
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variance/variance-associated-types2.stderr b/tests/ui/variance/variance-associated-types2.stderr
index 35871c1236f..158b09b0630 100644
--- a/tests/ui/variance/variance-associated-types2.stderr
+++ b/tests/ui/variance/variance-associated-types2.stderr
@@ -6,5 +6,5 @@ LL | fn take<'a>(_: &'a u32) {
 LL |     let _: Box<dyn Foo<Bar = &'a u32>> = make();
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ type annotation requires that `'a` must outlive `'static`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variance/variance-cell-is-invariant.stderr b/tests/ui/variance/variance-cell-is-invariant.stderr
index ab5435d1656..18e2de9f502 100644
--- a/tests/ui/variance/variance-cell-is-invariant.stderr
+++ b/tests/ui/variance/variance-cell-is-invariant.stderr
@@ -14,5 +14,5 @@ LL |     let _: Foo<'long> = c;
    = note: the struct `Foo<'a>` is invariant over the parameter `'a`
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variance/variance-object-types.stderr b/tests/ui/variance/variance-object-types.stderr
index 55a760425ee..963f3454e1b 100644
--- a/tests/ui/variance/variance-object-types.stderr
+++ b/tests/ui/variance/variance-object-types.stderr
@@ -4,5 +4,5 @@ error: [o]
 LL | struct Foo<'a> {
    | ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variance/variance-trait-matching.stderr b/tests/ui/variance/variance-trait-matching.stderr
index 3308cc6d250..9c72fe239dd 100644
--- a/tests/ui/variance/variance-trait-matching.stderr
+++ b/tests/ui/variance/variance-trait-matching.stderr
@@ -7,6 +7,6 @@ LL | fn get<'a, G>(get: &G) -> i32
 LL |     pick(get, &22)
    |     ^^^^^^^^^^^^^^ lifetime `'a` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/variance/variance-trait-object-bound.stderr b/tests/ui/variance/variance-trait-object-bound.stderr
index bfcc8d4a1d1..f0471a34619 100644
--- a/tests/ui/variance/variance-trait-object-bound.stderr
+++ b/tests/ui/variance/variance-trait-object-bound.stderr
@@ -4,5 +4,5 @@ error: [+]
 LL | struct TOption<'a> {
    | ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variance/variance-use-contravariant-struct-1.stderr b/tests/ui/variance/variance-use-contravariant-struct-1.stderr
index 50de7c90f13..5000787b8f9 100644
--- a/tests/ui/variance/variance-use-contravariant-struct-1.stderr
+++ b/tests/ui/variance/variance-use-contravariant-struct-1.stderr
@@ -11,5 +11,5 @@ LL |     v
    |
    = help: consider adding the following bound: `'min: 'max`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variance/variance-use-covariant-struct-1.stderr b/tests/ui/variance/variance-use-covariant-struct-1.stderr
index bab858c5acb..bd8458cd85d 100644
--- a/tests/ui/variance/variance-use-covariant-struct-1.stderr
+++ b/tests/ui/variance/variance-use-covariant-struct-1.stderr
@@ -11,5 +11,5 @@ LL |     v
    |
    = help: consider adding the following bound: `'min: 'max`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/variants/variant-size-differences.stderr b/tests/ui/variants/variant-size-differences.stderr
index 241a757d445..cbc3eabd1d1 100644
--- a/tests/ui/variants/variant-size-differences.stderr
+++ b/tests/ui/variants/variant-size-differences.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(variant_size_differences)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/walk-struct-literal-with.stderr b/tests/ui/walk-struct-literal-with.stderr
index 2b85fa9bed4..34b501f8ec8 100644
--- a/tests/ui/walk-struct-literal-with.stderr
+++ b/tests/ui/walk-struct-literal-with.stderr
@@ -15,6 +15,6 @@ LL |     fn make_string_bar(mut self) -> Mine{
    |                            ^^^^
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/wf/issue-103573.stderr b/tests/ui/wf/issue-103573.stderr
index 5227badb77d..3129f2a8c34 100644
--- a/tests/ui/wf/issue-103573.stderr
+++ b/tests/ui/wf/issue-103573.stderr
@@ -9,6 +9,6 @@ help: consider further restricting the associated type
 LL |     fn g<'a>(_: &<<Self::TypeC<'a> as TraitB>::TypeB as TraitA>::TypeA) where <<Self as TraitC<E>>::TypeC<'a> as TraitB>::TypeB: TraitA;
    |                                                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/issue-87495.stderr b/tests/ui/wf/issue-87495.stderr
index c924cd87997..3ccfd7f8d79 100644
--- a/tests/ui/wf/issue-87495.stderr
+++ b/tests/ui/wf/issue-87495.stderr
@@ -13,6 +13,6 @@ LL |     const CONST: (bool, dyn T);
    |           ^^^^^ ...because it contains this associated `const`
    = help: consider moving `CONST` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/wf/issue-95665.stderr b/tests/ui/wf/issue-95665.stderr
index f80cd41a4c2..1b14045d558 100644
--- a/tests/ui/wf/issue-95665.stderr
+++ b/tests/ui/wf/issue-95665.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Struct`
 LL | pub struct Struct<T: Trait> {
    |                      ^^^^^ required by this bound in `Struct`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/issue-96810.stderr b/tests/ui/wf/issue-96810.stderr
index 1407e62b1e1..622d72f791e 100644
--- a/tests/ui/wf/issue-96810.stderr
+++ b/tests/ui/wf/issue-96810.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `K`
 LL | struct Hoge<K: Tr> {
    |              ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-array-elem-sized.stderr b/tests/ui/wf/wf-array-elem-sized.stderr
index 7f3c58d6bba..6bca8d036d5 100644
--- a/tests/ui/wf/wf-array-elem-sized.stderr
+++ b/tests/ui/wf/wf-array-elem-sized.stderr
@@ -7,6 +7,6 @@ LL |     foo: [[u8]],
    = help: the trait `Sized` is not implemented for `[u8]`
    = note: slice and array elements must have `Sized` type
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-complex-assoc-type.stderr b/tests/ui/wf/wf-complex-assoc-type.stderr
index 6a623bec815..161ee9d7059 100644
--- a/tests/ui/wf/wf-complex-assoc-type.stderr
+++ b/tests/ui/wf/wf-complex-assoc-type.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `AssertMyTrait`
 LL | struct AssertMyTrait<T: MyTrait>(T);
    |                         ^^^^^^^ required by this bound in `AssertMyTrait`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-enum-bound.stderr b/tests/ui/wf/wf-enum-bound.stderr
index d39fc0c6a45..78b5c6ec20e 100644
--- a/tests/ui/wf/wf-enum-bound.stderr
+++ b/tests/ui/wf/wf-enum-bound.stderr
@@ -14,6 +14,6 @@ help: consider further restricting type parameter `U`
 LL |     where T: ExtraCopy<U>, U: std::marker::Copy
    |                          ++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-enum-fields-struct-variant.stderr b/tests/ui/wf/wf-enum-fields-struct-variant.stderr
index c12d62521f7..2f2c1c2d266 100644
--- a/tests/ui/wf/wf-enum-fields-struct-variant.stderr
+++ b/tests/ui/wf/wf-enum-fields-struct-variant.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `A`
 LL | enum AnotherEnum<A: std::marker::Copy> {
    |                   +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-enum-fields.stderr b/tests/ui/wf/wf-enum-fields.stderr
index ac3301a965a..a5feaadfc75 100644
--- a/tests/ui/wf/wf-enum-fields.stderr
+++ b/tests/ui/wf/wf-enum-fields.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `A`
 LL | enum SomeEnum<A: std::marker::Copy> {
    |                +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-impl-associated-type-region.stderr b/tests/ui/wf/wf-impl-associated-type-region.stderr
index e6fb81247ad..f17d33474f4 100644
--- a/tests/ui/wf/wf-impl-associated-type-region.stderr
+++ b/tests/ui/wf/wf-impl-associated-type-region.stderr
@@ -11,6 +11,6 @@ help: consider adding an explicit lifetime bound
 LL | impl<'a, T: 'a> Foo<'a> for T {
    |           ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/wf/wf-impl-associated-type-trait.stderr b/tests/ui/wf/wf-impl-associated-type-trait.stderr
index bdf8bba5ee0..09e255bead0 100644
--- a/tests/ui/wf/wf-impl-associated-type-trait.stderr
+++ b/tests/ui/wf/wf-impl-associated-type-trait.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: MyHash> Foo for T {
    |       ++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-impl-self-type.stderr b/tests/ui/wf/wf-impl-self-type.stderr
index 1ca368729fe..86fe6df32bf 100644
--- a/tests/ui/wf/wf-impl-self-type.stderr
+++ b/tests/ui/wf/wf-impl-self-type.stderr
@@ -8,6 +8,6 @@ LL | impl Foo for Option<[u8]> {}
 note: required by a bound in `Option`
   --> $SRC_DIR/core/src/option.rs:LL:COL
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-in-fn-arg.stderr b/tests/ui/wf/wf-in-fn-arg.stderr
index 83a4a592ad3..8f22edd17a1 100644
--- a/tests/ui/wf/wf-in-fn-arg.stderr
+++ b/tests/ui/wf/wf-in-fn-arg.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | fn bar<T: std::marker::Copy>(_: &MustBeCopy<T>)
    |         +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-in-fn-ret.stderr b/tests/ui/wf/wf-in-fn-ret.stderr
index 7eeb9747283..85cf78c5987 100644
--- a/tests/ui/wf/wf-in-fn-ret.stderr
+++ b/tests/ui/wf/wf-in-fn-ret.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | fn bar<T: std::marker::Copy>() -> MustBeCopy<T>
    |         +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-in-fn-type-arg.stderr b/tests/ui/wf/wf-in-fn-type-arg.stderr
index be5e9d4182b..17594c813da 100644
--- a/tests/ui/wf/wf-in-fn-type-arg.stderr
+++ b/tests/ui/wf/wf-in-fn-type-arg.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | struct Bar<T: std::marker::Copy> {
    |             +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-in-fn-type-ret.stderr b/tests/ui/wf/wf-in-fn-type-ret.stderr
index 8fcfcb0b21a..fac535a1126 100644
--- a/tests/ui/wf/wf-in-fn-type-ret.stderr
+++ b/tests/ui/wf/wf-in-fn-type-ret.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | struct Foo<T: std::marker::Copy> {
    |             +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-in-fn-where-clause.stderr b/tests/ui/wf/wf-in-fn-where-clause.stderr
index 160a738409b..4c556d3d77d 100644
--- a/tests/ui/wf/wf-in-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-in-fn-where-clause.stderr
@@ -14,6 +14,6 @@ help: consider further restricting type parameter `U`
 LL |     where T: MustBeCopy<U>, U: std::marker::Copy
    |                           ++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr b/tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr
index b10856571a6..0af4ab022e1 100644
--- a/tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr
+++ b/tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr
@@ -9,6 +9,6 @@ help: indicate the anonymous lifetime
 LL | impl Trait for Ref<'_> {}
    |                   ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0726`.
diff --git a/tests/ui/wf/wf-in-obj-type-static.stderr b/tests/ui/wf/wf-in-obj-type-static.stderr
index 4b9b189164c..9e837b10e28 100644
--- a/tests/ui/wf/wf-in-obj-type-static.stderr
+++ b/tests/ui/wf/wf-in-obj-type-static.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL | struct Foo<T: 'static> {
    |             +++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0310`.
diff --git a/tests/ui/wf/wf-in-obj-type-trait.stderr b/tests/ui/wf/wf-in-obj-type-trait.stderr
index f556b678e0e..b96f56a12a5 100644
--- a/tests/ui/wf/wf-in-obj-type-trait.stderr
+++ b/tests/ui/wf/wf-in-obj-type-trait.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | struct Bar<T: std::marker::Copy> {
    |             +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
index e723d1ba76b..4cfbec12b6e 100644
--- a/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
+++ b/tests/ui/wf/wf-inherent-impl-method-where-clause.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `U`
 LL | impl<T,U: std::marker::Copy> Foo<T,U> {
    |         +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-inherent-impl-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-where-clause.stderr
index 39e0d348ea5..bdc1ee3e0e2 100644
--- a/tests/ui/wf/wf-inherent-impl-where-clause.stderr
+++ b/tests/ui/wf/wf-inherent-impl-where-clause.stderr
@@ -14,6 +14,6 @@ help: consider further restricting type parameter `U`
 LL | impl<T,U> Foo<T,U> where T: ExtraCopy<U>, U: std::marker::Copy
    |                                         ++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-object-safe.stderr b/tests/ui/wf/wf-object-safe.stderr
index 64969fbe320..cc5351346b3 100644
--- a/tests/ui/wf/wf-object-safe.stderr
+++ b/tests/ui/wf/wf-object-safe.stderr
@@ -13,6 +13,6 @@ LL |     fn foo(&self, _x: &Self);
    |                       ^^^^^ ...because method `foo` references the `Self` type in this parameter
    = help: consider moving `foo` to another trait
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/wf/wf-packed-on-proj-of-type-as-unimpl-trait.stderr b/tests/ui/wf/wf-packed-on-proj-of-type-as-unimpl-trait.stderr
index 52f46562c37..8e3088c6f4a 100644
--- a/tests/ui/wf/wf-packed-on-proj-of-type-as-unimpl-trait.stderr
+++ b/tests/ui/wf/wf-packed-on-proj-of-type-as-unimpl-trait.stderr
@@ -10,6 +10,6 @@ help: this trait has no implementations, consider adding one
 LL | pub trait Allocator { type Buffer; }
    | ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-struct-bound.stderr b/tests/ui/wf/wf-struct-bound.stderr
index 6248e3e4e43..4ac7f4634e4 100644
--- a/tests/ui/wf/wf-struct-bound.stderr
+++ b/tests/ui/wf/wf-struct-bound.stderr
@@ -14,6 +14,6 @@ help: consider further restricting type parameter `U`
 LL |     where T: ExtraCopy<U>, U: std::marker::Copy
    |                          ++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-struct-field.stderr b/tests/ui/wf/wf-struct-field.stderr
index 78a8da8602a..241ced3c2db 100644
--- a/tests/ui/wf/wf-struct-field.stderr
+++ b/tests/ui/wf/wf-struct-field.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `A`
 LL | struct SomeStruct<A: std::marker::Copy> {
    |                    +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-associated-type-bound.stderr b/tests/ui/wf/wf-trait-associated-type-bound.stderr
index 8297700171f..4ea895a9b03 100644
--- a/tests/ui/wf/wf-trait-associated-type-bound.stderr
+++ b/tests/ui/wf/wf-trait-associated-type-bound.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | trait SomeTrait<T: std::marker::Copy> {
    |                  +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-associated-type-region.stderr b/tests/ui/wf/wf-trait-associated-type-region.stderr
index ca7aeb55b25..d6647b2cb96 100644
--- a/tests/ui/wf/wf-trait-associated-type-region.stderr
+++ b/tests/ui/wf/wf-trait-associated-type-region.stderr
@@ -12,6 +12,6 @@ help: consider adding an explicit lifetime bound
 LL |     type Type2 = &'a Self::Type1 where <Self as SomeTrait<'a>>::Type1: 'a;
    |                                  ++++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/wf/wf-trait-associated-type-trait.stderr b/tests/ui/wf/wf-trait-associated-type-trait.stderr
index a73c3a2aed6..1dc8e2d87a2 100644
--- a/tests/ui/wf/wf-trait-associated-type-trait.stderr
+++ b/tests/ui/wf/wf-trait-associated-type-trait.stderr
@@ -14,6 +14,6 @@ help: consider further restricting the associated type
 LL | trait SomeTrait where <Self as SomeTrait>::Type1: Copy {
    |                 ++++++++++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-bound.stderr b/tests/ui/wf/wf-trait-bound.stderr
index bace3e3ef00..5845d05b38e 100644
--- a/tests/ui/wf/wf-trait-bound.stderr
+++ b/tests/ui/wf/wf-trait-bound.stderr
@@ -14,6 +14,6 @@ help: consider further restricting type parameter `U`
 LL |     where T: ExtraCopy<U>, U: std::marker::Copy
    |                          ++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-default-fn-arg.stderr b/tests/ui/wf/wf-trait-default-fn-arg.stderr
index 8c3d0568fdf..a885f898862 100644
--- a/tests/ui/wf/wf-trait-default-fn-arg.stderr
+++ b/tests/ui/wf/wf-trait-default-fn-arg.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL |     fn bar(&self, x: &Bar<Self>) where Self: Eq {
    |                                  ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-default-fn-ret.stderr b/tests/ui/wf/wf-trait-default-fn-ret.stderr
index 6422e862d28..f749ac7b1b3 100644
--- a/tests/ui/wf/wf-trait-default-fn-ret.stderr
+++ b/tests/ui/wf/wf-trait-default-fn-ret.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL |     fn bar(&self) -> Bar<Self> where Self: Eq {
    |                                ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-default-fn-where-clause.stderr b/tests/ui/wf/wf-trait-default-fn-where-clause.stderr
index f260d5750c5..e44a96fa589 100644
--- a/tests/ui/wf/wf-trait-default-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-trait-default-fn-where-clause.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL |     fn bar<A>(&self) where A: Bar<Self>, Self: Eq {
    |                                        ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-fn-arg.stderr b/tests/ui/wf/wf-trait-fn-arg.stderr
index 3bd1f48928d..8b35f36fa68 100644
--- a/tests/ui/wf/wf-trait-fn-arg.stderr
+++ b/tests/ui/wf/wf-trait-fn-arg.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL |     fn bar(&self, x: &Bar<Self>) where Self: Eq;
    |                                  ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-fn-ret.stderr b/tests/ui/wf/wf-trait-fn-ret.stderr
index 9bd3cc7711b..3d70f04def2 100644
--- a/tests/ui/wf/wf-trait-fn-ret.stderr
+++ b/tests/ui/wf/wf-trait-fn-ret.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL |     fn bar(&self) -> &Bar<Self> where Self: Eq;
    |                                 ++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-fn-where-clause.stderr b/tests/ui/wf/wf-trait-fn-where-clause.stderr
index d064f7fc56e..0ad3b58e7c7 100644
--- a/tests/ui/wf/wf-trait-fn-where-clause.stderr
+++ b/tests/ui/wf/wf-trait-fn-where-clause.stderr
@@ -14,6 +14,6 @@ help: consider further restricting `Self`
 LL |     fn bar(&self) where Self: Sized, Bar<Self>: Copy, Self: Eq;
    |                                                     ++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/wf/wf-trait-superbound.stderr b/tests/ui/wf/wf-trait-superbound.stderr
index cd49243a4bf..3c05065e57f 100644
--- a/tests/ui/wf/wf-trait-superbound.stderr
+++ b/tests/ui/wf/wf-trait-superbound.stderr
@@ -14,6 +14,6 @@ help: consider restricting type parameter `T`
 LL | trait SomeTrait<T: std::marker::Copy>: ExtraCopy<T> {
    |                  +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/higher-ranked-fn-type.quiet.stderr b/tests/ui/where-clauses/higher-ranked-fn-type.quiet.stderr
index 29b36f44a4d..4c15497d530 100644
--- a/tests/ui/where-clauses/higher-ranked-fn-type.quiet.stderr
+++ b/tests/ui/where-clauses/higher-ranked-fn-type.quiet.stderr
@@ -18,6 +18,6 @@ LL | where
 LL |     for<'b> fn(&'b ()): Foo,
    |                         ^^^ required by this bound in `called`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/higher-ranked-fn-type.verbose.stderr b/tests/ui/where-clauses/higher-ranked-fn-type.verbose.stderr
index 782e7dc5e00..3318c70f1bb 100644
--- a/tests/ui/where-clauses/higher-ranked-fn-type.verbose.stderr
+++ b/tests/ui/where-clauses/higher-ranked-fn-type.verbose.stderr
@@ -18,6 +18,6 @@ LL | where
 LL |     for<'b> fn(&'b ()): Foo,
    |                         ^^^ required by this bound in `called`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/ignore-err-clauses.stderr b/tests/ui/where-clauses/ignore-err-clauses.stderr
index cfddc3e10b6..4cf553da4c5 100644
--- a/tests/ui/where-clauses/ignore-err-clauses.stderr
+++ b/tests/ui/where-clauses/ignore-err-clauses.stderr
@@ -4,6 +4,6 @@ error[E0412]: cannot find type `UUU` in this scope
 LL |     UUU: Copy,
    |     ^^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/where-clauses/self-in-where-clause-allowed.stderr b/tests/ui/where-clauses/self-in-where-clause-allowed.stderr
index ea51f5084f8..7f92ac102f0 100644
--- a/tests/ui/where-clauses/self-in-where-clause-allowed.stderr
+++ b/tests/ui/where-clauses/self-in-where-clause-allowed.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Trait::autotrait_bound`
 LL |     fn autotrait_bound(&self) where Self: AutoTrait {}
    |                                           ^^^^^^^^^ required by this bound in `Trait::autotrait_bound`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr b/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
index 43fbc0a9061..2612cefef28 100644
--- a/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
+++ b/tests/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
@@ -16,6 +16,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::marker::Copy> Foo<T> {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr b/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
index f2db8fcc4a3..090df26a39e 100644
--- a/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
+++ b/tests/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
@@ -16,6 +16,6 @@ help: consider restricting type parameter `T`
 LL | impl<T: std::marker::Copy> Foo<T> for Bar<T> {
    |       +++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/where-clause-method-substituion.stderr b/tests/ui/where-clauses/where-clause-method-substituion.stderr
index 2f3b615a13b..1a1d9c13ab8 100644
--- a/tests/ui/where-clauses/where-clause-method-substituion.stderr
+++ b/tests/ui/where-clauses/where-clause-method-substituion.stderr
@@ -15,6 +15,6 @@ note: required by a bound in `Bar::method`
 LL |     fn method<B>(&self) where A: Foo<B>;
    |                                  ^^^^^^ required by this bound in `Bar::method`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/where-clauses-method-unsatisfied.stderr b/tests/ui/where-clauses/where-clauses-method-unsatisfied.stderr
index 6cf71729514..840df342ef9 100644
--- a/tests/ui/where-clauses/where-clauses-method-unsatisfied.stderr
+++ b/tests/ui/where-clauses/where-clauses-method-unsatisfied.stderr
@@ -15,6 +15,6 @@ LL + #[derive(Eq)]
 LL | struct Bar; // does not implement Eq
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/where-clauses-unsatisfied.stderr b/tests/ui/where-clauses/where-clauses-unsatisfied.stderr
index 4d239bf4307..205b82d49bf 100644
--- a/tests/ui/where-clauses/where-clauses-unsatisfied.stderr
+++ b/tests/ui/where-clauses/where-clauses-unsatisfied.stderr
@@ -15,6 +15,6 @@ LL + #[derive(Eq)]
 LL | struct Struct;
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/where-clauses/where-for-self-2.stderr b/tests/ui/where-clauses/where-for-self-2.stderr
index f65db78fc89..f4792107721 100644
--- a/tests/ui/where-clauses/where-for-self-2.stderr
+++ b/tests/ui/where-clauses/where-for-self-2.stderr
@@ -7,5 +7,5 @@ LL |     foo(&X);
    = note: `&'0 u32` must implement `Bar`, for any lifetime `'0`...
    = note: ...but `Bar` is actually implemented for the type `&'static u32`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/where-clauses/where-for-self.stderr b/tests/ui/where-clauses/where-for-self.stderr
index d06afc1e423..8936e45c19c 100644
--- a/tests/ui/where-clauses/where-for-self.stderr
+++ b/tests/ui/where-clauses/where-for-self.stderr
@@ -4,6 +4,6 @@ error[E0316]: nested quantification of lifetimes
 LL |     where for<'a> &'a T: for<'b> Bar<'b>
    |                          ^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0316`.
diff --git a/tests/ui/while/while-else-err.stderr b/tests/ui/while/while-else-err.stderr
index 88f715d5666..b937956108f 100644
--- a/tests/ui/while/while-else-err.stderr
+++ b/tests/ui/while/while-else-err.stderr
@@ -13,5 +13,5 @@ LL | |     };
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/while/while-else-let-else-err.stderr b/tests/ui/while/while-else-let-else-err.stderr
index 431d37c007c..27d68ffdb24 100644
--- a/tests/ui/while/while-else-let-else-err.stderr
+++ b/tests/ui/while/while-else-let-else-err.stderr
@@ -13,5 +13,5 @@ LL | |     };
    |
    = note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/windows-subsystem-invalid.stderr b/tests/ui/windows-subsystem-invalid.stderr
index 0cb843cf0f1..703f35c969c 100644
--- a/tests/ui/windows-subsystem-invalid.stderr
+++ b/tests/ui/windows-subsystem-invalid.stderr
@@ -1,4 +1,4 @@
 error: invalid windows subsystem `wrong`, only `windows` and `console` are allowed
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/writing-to-immutable-vec.stderr b/tests/ui/writing-to-immutable-vec.stderr
index 286267c3834..06e1684dffe 100644
--- a/tests/ui/writing-to-immutable-vec.stderr
+++ b/tests/ui/writing-to-immutable-vec.stderr
@@ -9,6 +9,6 @@ help: consider changing this to be mutable
 LL |     let mut v: Vec<isize> = vec![1, 2, 3];
    |         +++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0596`.

From 87a354b15d3fd3579610325b6a3061d28088b63f Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 16:44:51 +0000
Subject: [PATCH 66/71] Bless rustdoc-ui tests

Co-authored-by: Adrian <adrian.iosdev@gmail.com>
---
 tests/rustdoc-ui/bounded-hr-lifetime.stderr                     | 2 +-
 tests/rustdoc-ui/const-evalutation-ice.stderr                   | 2 +-
 tests/rustdoc-ui/const_arg_in_type_position.stderr              | 2 +-
 tests/rustdoc-ui/diagnostic-width.stderr                        | 2 +-
 tests/rustdoc-ui/doc-alias-assoc-const.stderr                   | 2 +-
 tests/rustdoc-ui/doc-alias-same-name.stderr                     | 2 +-
 tests/rustdoc-ui/doctest/doctest-edition.stderr                 | 2 +-
 .../doctest/failed-doctest-extra-semicolon-on-item.stdout       | 2 +-
 tests/rustdoc-ui/doctest/failed-doctest-missing-codes.stdout    | 2 +-
 tests/rustdoc-ui/doctest/failed-doctest-output.stdout           | 2 +-
 tests/rustdoc-ui/doctest/nocapture-fail.stderr                  | 2 +-
 tests/rustdoc-ui/doctest/private-item-doc-test.stderr           | 2 +-
 tests/rustdoc-ui/doctest/private-public-item-doc-test.stderr    | 2 +-
 tests/rustdoc-ui/doctest/test-compile-fail1.stderr              | 2 +-
 tests/rustdoc-ui/doctest/test-compile-fail2.stderr              | 2 +-
 tests/rustdoc-ui/doctest/test-compile-fail3.stderr              | 2 +-
 tests/rustdoc-ui/doctest/unparseable-doc-test.stdout            | 2 +-
 .../error-in-impl-trait/infinite-recursive-type-2.stderr        | 2 +-
 .../infinite-recursive-type-impl-trait-return.stderr            | 2 +-
 .../error-in-impl-trait/infinite-recursive-type.stderr          | 2 +-
 tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr               | 2 +-
 tests/rustdoc-ui/infinite-recursive-type.stderr                 | 2 +-
 tests/rustdoc-ui/intra-doc/alias-ice.stderr                     | 2 +-
 tests/rustdoc-ui/intra-doc/assoc-item-not-in-scope.stderr       | 2 +-
 tests/rustdoc-ui/intra-doc/crate-nonexistent.stderr             | 2 +-
 .../intra-doc/deny-intra-link-resolution-failure.stderr         | 2 +-
 tests/rustdoc-ui/intra-doc/field-ice.stderr                     | 2 +-
 .../intra-doc/incompatible-primitive-disambiguator.stderr       | 2 +-
 .../rustdoc-ui/intra-doc/issue-108653-associated-items-4.stderr | 2 +-
 .../rustdoc-ui/intra-doc/issue-108653-associated-items-5.stderr | 2 +-
 .../rustdoc-ui/intra-doc/issue-108653-associated-items-6.stderr | 2 +-
 .../rustdoc-ui/intra-doc/issue-108653-associated-items-7.stderr | 2 +-
 .../rustdoc-ui/intra-doc/issue-108653-associated-items-8.stderr | 2 +-
 tests/rustdoc-ui/intra-doc/pub-export-lint.stderr               | 2 +-
 tests/rustdoc-ui/intra-doc/reference-links.stderr               | 2 +-
 tests/rustdoc-ui/intra-doc/span-ice-55723.stderr                | 2 +-
 tests/rustdoc-ui/intra-doc/unresolved-import-recovery.stderr    | 2 +-
 tests/rustdoc-ui/intra-doc/unused-extern-crate.stderr           | 2 +-
 tests/rustdoc-ui/invalid-keyword.stderr                         | 2 +-
 tests/rustdoc-ui/invalid_associated_const.stderr                | 2 +-
 tests/rustdoc-ui/issue-102467.stderr                            | 2 +-
 tests/rustdoc-ui/issue-110629-private-type-cycle-dyn.stderr     | 2 +-
 tests/rustdoc-ui/issues/issue-102986.stderr                     | 2 +-
 tests/rustdoc-ui/issues/issue-105334.stderr                     | 2 +-
 tests/rustdoc-ui/issues/issue-105737.stderr                     | 2 +-
 tests/rustdoc-ui/issues/issue-106213.stderr                     | 2 +-
 tests/rustdoc-ui/issues/issue-106226.stderr                     | 2 +-
 tests/rustdoc-ui/issues/issue-61592-2.stderr                    | 2 +-
 tests/rustdoc-ui/issues/issue-61592.stderr                      | 2 +-
 tests/rustdoc-ui/issues/issue-61732.stderr                      | 2 +-
 tests/rustdoc-ui/issues/issue-79465.stderr                      | 2 +-
 tests/rustdoc-ui/issues/issue-79467.stderr                      | 2 +-
 tests/rustdoc-ui/issues/issue-81662-shortness.stdout            | 2 +-
 tests/rustdoc-ui/issues/issue-96287.stderr                      | 2 +-
 tests/rustdoc-ui/lints/deny-missing-docs-macro.stderr           | 2 +-
 tests/rustdoc-ui/lints/doc-spotlight.stderr                     | 2 +-
 .../lints/feature-gate-rustdoc_missing_doc_code_examples.stderr | 2 +-
 tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr           | 2 +-
 tests/rustdoc-ui/mismatched_arg_count.stderr                    | 2 +-
 tests/rustdoc-ui/not-wf-ambiguous-normalization.stderr          | 2 +-
 tests/rustdoc-ui/proc_macro_bug.stderr                          | 2 +-
 tests/rustdoc-ui/rustc-check-passes.stderr                      | 2 +-
 tests/rustdoc-ui/track-diagnostics.stderr                       | 2 +-
 tests/rustdoc-ui/tuple-variadic-check.stderr                    | 2 +-
 64 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/tests/rustdoc-ui/bounded-hr-lifetime.stderr b/tests/rustdoc-ui/bounded-hr-lifetime.stderr
index 580f70c9742..d7c4e8c380c 100644
--- a/tests/rustdoc-ui/bounded-hr-lifetime.stderr
+++ b/tests/rustdoc-ui/bounded-hr-lifetime.stderr
@@ -4,5 +4,5 @@ error: lifetime bounds cannot be used in this context
 LL |     for<'a: 'b + 'c> &'a (): std::fmt::Debug,
    |             ^^   ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/const-evalutation-ice.stderr b/tests/rustdoc-ui/const-evalutation-ice.stderr
index 5d9c16c0765..e1cb3323856 100644
--- a/tests/rustdoc-ui/const-evalutation-ice.stderr
+++ b/tests/rustdoc-ui/const-evalutation-ice.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL | pub const N: usize = 0 - (mem::size_of::<S>() != 400) as usize;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/rustdoc-ui/const_arg_in_type_position.stderr b/tests/rustdoc-ui/const_arg_in_type_position.stderr
index ea05920dea7..5345f77fd39 100644
--- a/tests/rustdoc-ui/const_arg_in_type_position.stderr
+++ b/tests/rustdoc-ui/const_arg_in_type_position.stderr
@@ -4,6 +4,6 @@ error[E0747]: constant provided when a type was expected
 LL | fn foo<const N: usize>() -> Array<N, ()> {
    |                                   ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/rustdoc-ui/diagnostic-width.stderr b/tests/rustdoc-ui/diagnostic-width.stderr
index 1a00d10d3fc..c1cc4898ac5 100644
--- a/tests/rustdoc-ui/diagnostic-width.stderr
+++ b/tests/rustdoc-ui/diagnostic-width.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | ...ny(rustdoc::bare_url...
    |       ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doc-alias-assoc-const.stderr b/tests/rustdoc-ui/doc-alias-assoc-const.stderr
index cbca40e1364..cd3ad4ab393 100644
--- a/tests/rustdoc-ui/doc-alias-assoc-const.stderr
+++ b/tests/rustdoc-ui/doc-alias-assoc-const.stderr
@@ -4,5 +4,5 @@ error: `#[doc(alias = "...")]` isn't allowed on associated constant in trait imp
 LL |     #[doc(alias = "CONST_BAZ")]
    |           ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doc-alias-same-name.stderr b/tests/rustdoc-ui/doc-alias-same-name.stderr
index 5ba09a2eae1..a9da75c0171 100644
--- a/tests/rustdoc-ui/doc-alias-same-name.stderr
+++ b/tests/rustdoc-ui/doc-alias-same-name.stderr
@@ -4,5 +4,5 @@ error: `#[doc(alias = "...")]` is the same as the item's name
 LL | #[doc(alias = "Foo")]
    |       ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/doctest-edition.stderr b/tests/rustdoc-ui/doctest/doctest-edition.stderr
index 8a3329aa3ed..1e9ebd88c2e 100644
--- a/tests/rustdoc-ui/doctest/doctest-edition.stderr
+++ b/tests/rustdoc-ui/doctest/doctest-edition.stderr
@@ -18,5 +18,5 @@ help: mark blocks that do not contain Rust code as text
 LL | //! ```text
    |        ++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stdout b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stdout
index 61468b6c745..e288f8dfce6 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stdout
@@ -13,7 +13,7 @@ LL | struct S {}; // unexpected semicolon after struct def
    |
    = help: braced struct declarations are not followed by a semicolon
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 Couldn't compile the test.
 
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.stdout b/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.stdout
index bacbb47b5f9..11355c232fe 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-missing-codes.stdout
@@ -13,7 +13,7 @@ LL | let x: () = 5i32;
    |        |
    |        expected due to this
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
 Some expected error codes were not found: ["E0004"]
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output.stdout b/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
index 840c9c5084c..7b0cf9a432d 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
@@ -12,7 +12,7 @@ error[E0425]: cannot find value `no` in this scope
 LL | no
    | ^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
 Couldn't compile the test.
diff --git a/tests/rustdoc-ui/doctest/nocapture-fail.stderr b/tests/rustdoc-ui/doctest/nocapture-fail.stderr
index b65b622c1ed..c6a5785a24f 100644
--- a/tests/rustdoc-ui/doctest/nocapture-fail.stderr
+++ b/tests/rustdoc-ui/doctest/nocapture-fail.stderr
@@ -14,5 +14,5 @@ LL |     Input: 123
 LL ~ } }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/private-item-doc-test.stderr b/tests/rustdoc-ui/doctest/private-item-doc-test.stderr
index 5df6132987c..5177057c728 100644
--- a/tests/rustdoc-ui/doctest/private-item-doc-test.stderr
+++ b/tests/rustdoc-ui/doctest/private-item-doc-test.stderr
@@ -14,5 +14,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::private_doc_tests)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/private-public-item-doc-test.stderr b/tests/rustdoc-ui/doctest/private-public-item-doc-test.stderr
index f50dbd1844e..38b8dd652d3 100644
--- a/tests/rustdoc-ui/doctest/private-public-item-doc-test.stderr
+++ b/tests/rustdoc-ui/doctest/private-public-item-doc-test.stderr
@@ -14,5 +14,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::private_doc_tests)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail1.stderr b/tests/rustdoc-ui/doctest/test-compile-fail1.stderr
index 72915e46bec..02f4d8d754f 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail1.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail1.stderr
@@ -9,6 +9,6 @@ error[E0428]: the name `f` is defined multiple times
   |
   = note: `f` must be defined only once in the value namespace of this module
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0428`.
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail2.stderr b/tests/rustdoc-ui/doctest/test-compile-fail2.stderr
index cee5b63cf50..f0ad40eb6ca 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail2.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail2.stderr
@@ -4,5 +4,5 @@ error: expected one of `!` or `::`, found `<eof>`
 3 | fail
   | ^^^^ expected one of `!` or `::`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail3.stderr b/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
index fab801b3bea..1ed45542251 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
@@ -4,6 +4,6 @@ error[E0765]: unterminated double quote string
 3 | "fail
   | ^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0765`.
diff --git a/tests/rustdoc-ui/doctest/unparseable-doc-test.stdout b/tests/rustdoc-ui/doctest/unparseable-doc-test.stdout
index 2641c66f25e..0574dc8b282 100644
--- a/tests/rustdoc-ui/doctest/unparseable-doc-test.stdout
+++ b/tests/rustdoc-ui/doctest/unparseable-doc-test.stdout
@@ -11,7 +11,7 @@ error[E0765]: unterminated double quote string
 LL | "unterminated
    | ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0765`.
 Couldn't compile the test.
diff --git a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-2.stderr b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-2.stderr
index edb5dfd4d55..69e2eebcdd8 100644
--- a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-2.stderr
+++ b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-2.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |         V(Box<E>),
    |           ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.stderr b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.stderr
index aff7402bc91..c169ca670a6 100644
--- a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.stderr
+++ b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type-impl-trait-return.stderr
@@ -11,6 +11,6 @@ help: insert some indirection (e.g., a `DEF_ID`) to break the cycle
 LL |         This(Box<E>),
    |              ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `DEF_ID`.
diff --git a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type.stderr b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type.stderr
index 349a569414c..bd5de384cde 100644
--- a/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type.stderr
+++ b/tests/rustdoc-ui/error-in-impl-trait/infinite-recursive-type.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |         V(Box<E>),
    |           ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
index 0864159c8e2..0b982cd9fd3 100644
--- a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
@@ -7,6 +7,6 @@ LL | #![doc(cfg_hide(test))]
    = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
    = help: add `#![feature(doc_cfg_hide)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/rustdoc-ui/infinite-recursive-type.stderr b/tests/rustdoc-ui/infinite-recursive-type.stderr
index 9e2c3ff1642..cc914de6d1e 100644
--- a/tests/rustdoc-ui/infinite-recursive-type.stderr
+++ b/tests/rustdoc-ui/infinite-recursive-type.stderr
@@ -12,6 +12,6 @@ help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
 LL |     V(Box<E>),
    |       ++++ +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/rustdoc-ui/intra-doc/alias-ice.stderr b/tests/rustdoc-ui/intra-doc/alias-ice.stderr
index 5e7ffeeb8a2..a38df98433d 100644
--- a/tests/rustdoc-ui/intra-doc/alias-ice.stderr
+++ b/tests/rustdoc-ui/intra-doc/alias-ice.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/assoc-item-not-in-scope.stderr b/tests/rustdoc-ui/intra-doc/assoc-item-not-in-scope.stderr
index 04594ad4142..7ce677e863b 100644
--- a/tests/rustdoc-ui/intra-doc/assoc-item-not-in-scope.stderr
+++ b/tests/rustdoc-ui/intra-doc/assoc-item-not-in-scope.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/crate-nonexistent.stderr b/tests/rustdoc-ui/intra-doc/crate-nonexistent.stderr
index a69b1c52ac5..5dc61017960 100644
--- a/tests/rustdoc-ui/intra-doc/crate-nonexistent.stderr
+++ b/tests/rustdoc-ui/intra-doc/crate-nonexistent.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/deny-intra-link-resolution-failure.stderr b/tests/rustdoc-ui/intra-doc/deny-intra-link-resolution-failure.stderr
index 3e08354a61d..ace20a5fe97 100644
--- a/tests/rustdoc-ui/intra-doc/deny-intra-link-resolution-failure.stderr
+++ b/tests/rustdoc-ui/intra-doc/deny-intra-link-resolution-failure.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/field-ice.stderr b/tests/rustdoc-ui/intra-doc/field-ice.stderr
index f45a3ca615b..cc0ada873af 100644
--- a/tests/rustdoc-ui/intra-doc/field-ice.stderr
+++ b/tests/rustdoc-ui/intra-doc/field-ice.stderr
@@ -14,5 +14,5 @@ help: to link to the field, remove the disambiguator
 LL | /// [`Foo::bar`]
    |       ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr b/tests/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr
index c43cda3eb7e..b952517022b 100644
--- a/tests/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr
+++ b/tests/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr
@@ -14,5 +14,5 @@ help: to link to the associated constant, prefix with `const@`
 LL | //! [const@u8::MIN]
    |      ~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-4.stderr b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-4.stderr
index a8dc91204c0..9d16219be2f 100644
--- a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-4.stderr
+++ b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-4.stderr
@@ -18,5 +18,5 @@ help: to link to the associated type, prefix with `type@`
 LL | /// [`type@Struct::Trait`]
    |       +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-5.stderr b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-5.stderr
index 7430044ac3f..f7dabed2979 100644
--- a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-5.stderr
+++ b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-5.stderr
@@ -18,5 +18,5 @@ help: to link to the trait, prefix with `trait@`
 LL | /// [`trait@u32::MAX`]
    |       ++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-6.stderr b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-6.stderr
index fe2d8cafa30..baf23e94f45 100644
--- a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-6.stderr
+++ b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-6.stderr
@@ -18,5 +18,5 @@ help: to link to the primitive type, prefix with `prim@`
 LL | /// [`prim@u32::MAX`]
    |       +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-7.stderr b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-7.stderr
index 1d302ff42e8..54235275476 100644
--- a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-7.stderr
+++ b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-7.stderr
@@ -18,5 +18,5 @@ help: to link to the associated type, prefix with `type@`
 LL | /// [`type@u32::MAX`]
    |       +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-8.stderr b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-8.stderr
index efed0e2ce0f..a2641c25170 100644
--- a/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-8.stderr
+++ b/tests/rustdoc-ui/intra-doc/issue-108653-associated-items-8.stderr
@@ -18,5 +18,5 @@ help: to link to the associated type, prefix with `type@`
 LL | /// [`type@u32::MAX`]
    |       +++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/pub-export-lint.stderr b/tests/rustdoc-ui/intra-doc/pub-export-lint.stderr
index 81ef799617c..b037b7933ca 100644
--- a/tests/rustdoc-ui/intra-doc/pub-export-lint.stderr
+++ b/tests/rustdoc-ui/intra-doc/pub-export-lint.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/reference-links.stderr b/tests/rustdoc-ui/intra-doc/reference-links.stderr
index c98a2fd7ce6..2a30359238a 100644
--- a/tests/rustdoc-ui/intra-doc/reference-links.stderr
+++ b/tests/rustdoc-ui/intra-doc/reference-links.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/span-ice-55723.stderr b/tests/rustdoc-ui/intra-doc/span-ice-55723.stderr
index e8ee40ad4e8..765f26c4845 100644
--- a/tests/rustdoc-ui/intra-doc/span-ice-55723.stderr
+++ b/tests/rustdoc-ui/intra-doc/span-ice-55723.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/intra-doc/unresolved-import-recovery.stderr b/tests/rustdoc-ui/intra-doc/unresolved-import-recovery.stderr
index 14f56061852..8315c73a639 100644
--- a/tests/rustdoc-ui/intra-doc/unresolved-import-recovery.stderr
+++ b/tests/rustdoc-ui/intra-doc/unresolved-import-recovery.stderr
@@ -6,6 +6,6 @@ LL | use unresolved_crate::module::Name;
    |
    = help: consider adding `extern crate unresolved_crate` to use the `unresolved_crate` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/rustdoc-ui/intra-doc/unused-extern-crate.stderr b/tests/rustdoc-ui/intra-doc/unused-extern-crate.stderr
index 815324563cb..f9f135a922b 100644
--- a/tests/rustdoc-ui/intra-doc/unused-extern-crate.stderr
+++ b/tests/rustdoc-ui/intra-doc/unused-extern-crate.stderr
@@ -11,5 +11,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/invalid-keyword.stderr b/tests/rustdoc-ui/invalid-keyword.stderr
index 8658e382578..82faaaab47f 100644
--- a/tests/rustdoc-ui/invalid-keyword.stderr
+++ b/tests/rustdoc-ui/invalid-keyword.stderr
@@ -4,5 +4,5 @@ error: `foo df` is not a valid identifier
 LL | #[doc(keyword = "foo df")]
    |                 ^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/invalid_associated_const.stderr b/tests/rustdoc-ui/invalid_associated_const.stderr
index 1a8863fb18f..9c6ae0f76c6 100644
--- a/tests/rustdoc-ui/invalid_associated_const.stderr
+++ b/tests/rustdoc-ui/invalid_associated_const.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     type A: S<C<X = 0i32> = 34>;
    |                 ^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/rustdoc-ui/issue-102467.stderr b/tests/rustdoc-ui/issue-102467.stderr
index a337293f7a0..4a769f94cf2 100644
--- a/tests/rustdoc-ui/issue-102467.stderr
+++ b/tests/rustdoc-ui/issue-102467.stderr
@@ -4,6 +4,6 @@ error[E0229]: associated type bindings are not allowed here
 LL |     type A: S<C<X = 0i32> = 34>;
    |                 ^^^^^^^^ associated type not allowed here
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0229`.
diff --git a/tests/rustdoc-ui/issue-110629-private-type-cycle-dyn.stderr b/tests/rustdoc-ui/issue-110629-private-type-cycle-dyn.stderr
index 9aeb3389e2d..d056dde00ea 100644
--- a/tests/rustdoc-ui/issue-110629-private-type-cycle-dyn.stderr
+++ b/tests/rustdoc-ui/issue-110629-private-type-cycle-dyn.stderr
@@ -21,6 +21,6 @@ LL | | }
    | |_^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/rustdoc-ui/issues/issue-102986.stderr b/tests/rustdoc-ui/issues/issue-102986.stderr
index 3a573726c97..996eb41c492 100644
--- a/tests/rustdoc-ui/issues/issue-102986.stderr
+++ b/tests/rustdoc-ui/issues/issue-102986.stderr
@@ -9,6 +9,6 @@ help: consider replacing `typeof(...)` with an actual type
 LL |     y: (&'static str,),
    |         ~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0516`.
diff --git a/tests/rustdoc-ui/issues/issue-105334.stderr b/tests/rustdoc-ui/issues/issue-105334.stderr
index e163bb4db9e..d992b219b3b 100644
--- a/tests/rustdoc-ui/issues/issue-105334.stderr
+++ b/tests/rustdoc-ui/issues/issue-105334.stderr
@@ -4,6 +4,6 @@ error[E0747]: constant provided when a type was expected
 LL | impl Vec< br##"*.."## > {}
    |           ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/rustdoc-ui/issues/issue-105737.stderr b/tests/rustdoc-ui/issues/issue-105737.stderr
index 2dd9beb17da..2c63c345e46 100644
--- a/tests/rustdoc-ui/issues/issue-105737.stderr
+++ b/tests/rustdoc-ui/issues/issue-105737.stderr
@@ -7,6 +7,6 @@ LL | impl Vec<lol> {}
    = help: `lol` is a function item, not a type
    = help: function item types cannot be named directly
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0747`.
diff --git a/tests/rustdoc-ui/issues/issue-106213.stderr b/tests/rustdoc-ui/issues/issue-106213.stderr
index 0a4ff69bafb..fa79fe2e71c 100644
--- a/tests/rustdoc-ui/issues/issue-106213.stderr
+++ b/tests/rustdoc-ui/issues/issue-106213.stderr
@@ -4,6 +4,6 @@ error[E0224]: at least one trait is required for an object type
 LL | fn use_avx() -> dyn  {
    |                 ^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0224`.
diff --git a/tests/rustdoc-ui/issues/issue-106226.stderr b/tests/rustdoc-ui/issues/issue-106226.stderr
index 1c973dab61d..4d063b46188 100644
--- a/tests/rustdoc-ui/issues/issue-106226.stderr
+++ b/tests/rustdoc-ui/issues/issue-106226.stderr
@@ -4,6 +4,6 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
 LL | type F = [_; ()];
    |           ^ not allowed in type signatures
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0121`.
diff --git a/tests/rustdoc-ui/issues/issue-61592-2.stderr b/tests/rustdoc-ui/issues/issue-61592-2.stderr
index 1b7f8bb552c..de376ad809e 100644
--- a/tests/rustdoc-ui/issues/issue-61592-2.stderr
+++ b/tests/rustdoc-ui/issues/issue-61592-2.stderr
@@ -7,6 +7,6 @@ LL | #[doc = "baz"]
 LL | pub use foo::Foo as _;
    | ---------------------- anonymous import
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0780`.
diff --git a/tests/rustdoc-ui/issues/issue-61592.stderr b/tests/rustdoc-ui/issues/issue-61592.stderr
index 9c9c9106f8a..0b96b659309 100644
--- a/tests/rustdoc-ui/issues/issue-61592.stderr
+++ b/tests/rustdoc-ui/issues/issue-61592.stderr
@@ -6,6 +6,6 @@ LL | #[doc(inline)]
 LL | pub use foo::Foo as _;
    | ---------------------- anonymous import
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0780`.
diff --git a/tests/rustdoc-ui/issues/issue-61732.stderr b/tests/rustdoc-ui/issues/issue-61732.stderr
index d16ec6a853a..f351f52d1e1 100644
--- a/tests/rustdoc-ui/issues/issue-61732.stderr
+++ b/tests/rustdoc-ui/issues/issue-61732.stderr
@@ -6,6 +6,6 @@ LL | pub(in crate::r#mod) fn main() {}
    |
    = help: consider adding `extern crate r#mod` to use the `r#mod` crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/rustdoc-ui/issues/issue-79465.stderr b/tests/rustdoc-ui/issues/issue-79465.stderr
index d187a2e664a..e7b433268e8 100644
--- a/tests/rustdoc-ui/issues/issue-79465.stderr
+++ b/tests/rustdoc-ui/issues/issue-79465.stderr
@@ -4,6 +4,6 @@ error[E0220]: associated type `A` not found for `T`
 LL | pub fn f1<T>(x: T::A) {}
    |                    ^ associated type `A` not found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/rustdoc-ui/issues/issue-79467.stderr b/tests/rustdoc-ui/issues/issue-79467.stderr
index 561513a432b..cb030a3113f 100644
--- a/tests/rustdoc-ui/issues/issue-79467.stderr
+++ b/tests/rustdoc-ui/issues/issue-79467.stderr
@@ -4,6 +4,6 @@ error[E0224]: at least one trait is required for an object type
 LL |     dyn 'static: 'static + Copy,
    |     ^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0224`.
diff --git a/tests/rustdoc-ui/issues/issue-81662-shortness.stdout b/tests/rustdoc-ui/issues/issue-81662-shortness.stdout
index 748113be3a2..6313dde32c5 100644
--- a/tests/rustdoc-ui/issues/issue-81662-shortness.stdout
+++ b/tests/rustdoc-ui/issues/issue-81662-shortness.stdout
@@ -6,7 +6,7 @@ failures:
 
 ---- $DIR/issue-81662-shortness.rs - foo (line 6) stdout ----
 $DIR/issue-81662-shortness.rs:7:1: error[E0425]: cannot find function `foo` in this scope
-error: aborting due to previous error
+error: aborting due to 1 previous error
 Couldn't compile the test.
 
 failures:
diff --git a/tests/rustdoc-ui/issues/issue-96287.stderr b/tests/rustdoc-ui/issues/issue-96287.stderr
index c4809a311fc..62d81534a98 100644
--- a/tests/rustdoc-ui/issues/issue-96287.stderr
+++ b/tests/rustdoc-ui/issues/issue-96287.stderr
@@ -9,6 +9,6 @@ help: consider restricting type parameter `V`
 LL | pub type Foo<V: TraitWithAssoc> = impl Trait<V::Assoc>;
    |               ++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0220`.
diff --git a/tests/rustdoc-ui/lints/deny-missing-docs-macro.stderr b/tests/rustdoc-ui/lints/deny-missing-docs-macro.stderr
index 0867b08183e..24597f09db6 100644
--- a/tests/rustdoc-ui/lints/deny-missing-docs-macro.stderr
+++ b/tests/rustdoc-ui/lints/deny-missing-docs-macro.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(missing_docs)]
    |         ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/lints/doc-spotlight.stderr b/tests/rustdoc-ui/lints/doc-spotlight.stderr
index 58612327ff9..5d93b4132fc 100644
--- a/tests/rustdoc-ui/lints/doc-spotlight.stderr
+++ b/tests/rustdoc-ui/lints/doc-spotlight.stderr
@@ -15,5 +15,5 @@ LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(invalid_doc_attributes)]` implied by `#[deny(warnings)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/lints/feature-gate-rustdoc_missing_doc_code_examples.stderr b/tests/rustdoc-ui/lints/feature-gate-rustdoc_missing_doc_code_examples.stderr
index b8a08e94312..f188240062d 100644
--- a/tests/rustdoc-ui/lints/feature-gate-rustdoc_missing_doc_code_examples.stderr
+++ b/tests/rustdoc-ui/lints/feature-gate-rustdoc_missing_doc_code_examples.stderr
@@ -13,5 +13,5 @@ note: the lint level is defined here
 LL | #![deny(unknown_lints)]
    |         ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr
index fb3a5e415df..3a748335ea8 100644
--- a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr
+++ b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr
@@ -8,5 +8,5 @@ note: the lint level is defined here
 LL | #![deny(rustdoc::missing_crate_level_docs)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/mismatched_arg_count.stderr b/tests/rustdoc-ui/mismatched_arg_count.stderr
index 7e88ce954ac..857bbda2ef4 100644
--- a/tests/rustdoc-ui/mismatched_arg_count.stderr
+++ b/tests/rustdoc-ui/mismatched_arg_count.stderr
@@ -12,6 +12,6 @@ note: type alias defined here, with 1 lifetime parameter: `'a`
 LL | type Alias<'a, T> = <T as Trait<'a>>::Assoc;
    |      ^^^^^ --
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/rustdoc-ui/not-wf-ambiguous-normalization.stderr b/tests/rustdoc-ui/not-wf-ambiguous-normalization.stderr
index 34b20a0b32c..01034018e22 100644
--- a/tests/rustdoc-ui/not-wf-ambiguous-normalization.stderr
+++ b/tests/rustdoc-ui/not-wf-ambiguous-normalization.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL | impl<T> Allocator for DefaultAllocator {
    |                       ^^^^^^^^^^^^^^^^ cannot infer type for type parameter `T`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/rustdoc-ui/proc_macro_bug.stderr b/tests/rustdoc-ui/proc_macro_bug.stderr
index 5b048097c49..77bdf201924 100644
--- a/tests/rustdoc-ui/proc_macro_bug.stderr
+++ b/tests/rustdoc-ui/proc_macro_bug.stderr
@@ -4,5 +4,5 @@ error: the `#[proc_macro_derive]` attribute is only usable with crates of the `p
 LL | #[proc_macro_derive(DeriveA)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/rustc-check-passes.stderr b/tests/rustdoc-ui/rustc-check-passes.stderr
index 83f4e87c6ed..58d61c0213e 100644
--- a/tests/rustdoc-ui/rustc-check-passes.stderr
+++ b/tests/rustdoc-ui/rustc-check-passes.stderr
@@ -4,6 +4,6 @@ error[E0636]: the feature `rustdoc_internals` has already been declared
 LL | #![feature(rustdoc_internals)]
    |            ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0636`.
diff --git a/tests/rustdoc-ui/track-diagnostics.stderr b/tests/rustdoc-ui/track-diagnostics.stderr
index 39418d35928..131adfd588c 100644
--- a/tests/rustdoc-ui/track-diagnostics.stderr
+++ b/tests/rustdoc-ui/track-diagnostics.stderr
@@ -5,6 +5,6 @@ LL | const S: A = B;
    |              ^ expected `A`, found `B`
 -Ztrack-diagnostics: created at compiler/rustc_infer/src/infer/error_reporting/mod.rs:LL:CC
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/rustdoc-ui/tuple-variadic-check.stderr b/tests/rustdoc-ui/tuple-variadic-check.stderr
index d127fb858d1..51fb87214fd 100644
--- a/tests/rustdoc-ui/tuple-variadic-check.stderr
+++ b/tests/rustdoc-ui/tuple-variadic-check.stderr
@@ -4,5 +4,5 @@ error: `#[doc(fake_variadic)]` must be used on the first of a set of tuple or fn
 LL | #[doc(fake_variadic)]
    |       ^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 

From 0346765100b6499107a9a964638921c2cc641ee2 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 17:08:25 +0000
Subject: [PATCH 67/71] Bless run-make tests

Co-authored-by: Adrian <adrian.iosdev@gmail.com>
---
 tests/run-make/emit-to-stdout/emit-link.stderr           | 2 +-
 tests/run-make/emit-to-stdout/emit-llvm-bc.stderr        | 2 +-
 tests/run-make/emit-to-stdout/emit-metadata.stderr       | 2 +-
 tests/run-make/emit-to-stdout/emit-multiple-types.stderr | 2 +-
 tests/run-make/emit-to-stdout/emit-obj.stderr            | 2 +-
 tests/run-make/jobserver-error/jobserver.stderr          | 2 +-
 tests/run-make/overwrite-input/file.stderr               | 2 +-
 tests/run-make/overwrite-input/folder.stderr             | 2 +-
 tests/run-make/overwrite-input/main.stderr               | 2 +-
 tests/run-make/unknown-mod-stdin/unknown-mod.stderr      | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/run-make/emit-to-stdout/emit-link.stderr b/tests/run-make/emit-to-stdout/emit-link.stderr
index a9d856503e6..0553b22a45e 100644
--- a/tests/run-make/emit-to-stdout/emit-link.stderr
+++ b/tests/run-make/emit-to-stdout/emit-link.stderr
@@ -1,4 +1,4 @@
 error: option `-o` or `--emit` is used to write binary output type `link` to stdout, but stdout is a tty
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/run-make/emit-to-stdout/emit-llvm-bc.stderr b/tests/run-make/emit-to-stdout/emit-llvm-bc.stderr
index 7b53bd16e7a..a50148f9ea8 100644
--- a/tests/run-make/emit-to-stdout/emit-llvm-bc.stderr
+++ b/tests/run-make/emit-to-stdout/emit-llvm-bc.stderr
@@ -1,4 +1,4 @@
 error: option `-o` or `--emit` is used to write binary output type `llvm-bc` to stdout, but stdout is a tty
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/run-make/emit-to-stdout/emit-metadata.stderr b/tests/run-make/emit-to-stdout/emit-metadata.stderr
index ee1e52937b9..27ad5d52921 100644
--- a/tests/run-make/emit-to-stdout/emit-metadata.stderr
+++ b/tests/run-make/emit-to-stdout/emit-metadata.stderr
@@ -1,4 +1,4 @@
 error: option `-o` or `--emit` is used to write binary output type `metadata` to stdout, but stdout is a tty
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/run-make/emit-to-stdout/emit-multiple-types.stderr b/tests/run-make/emit-to-stdout/emit-multiple-types.stderr
index b8a683cd9eb..4f74cb8409a 100644
--- a/tests/run-make/emit-to-stdout/emit-multiple-types.stderr
+++ b/tests/run-make/emit-to-stdout/emit-multiple-types.stderr
@@ -1,4 +1,4 @@
 error: can't use option `-o` or `--emit` to write multiple output types to stdout
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/run-make/emit-to-stdout/emit-obj.stderr b/tests/run-make/emit-to-stdout/emit-obj.stderr
index b1303530844..9bbcea01051 100644
--- a/tests/run-make/emit-to-stdout/emit-obj.stderr
+++ b/tests/run-make/emit-to-stdout/emit-obj.stderr
@@ -1,4 +1,4 @@
 error: option `-o` or `--emit` is used to write binary output type `obj` to stdout, but stdout is a tty
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/run-make/jobserver-error/jobserver.stderr b/tests/run-make/jobserver-error/jobserver.stderr
index d18e15a2628..d129db9bc67 100644
--- a/tests/run-make/jobserver-error/jobserver.stderr
+++ b/tests/run-make/jobserver-error/jobserver.stderr
@@ -1,4 +1,4 @@
 error: failed to acquire jobserver token: early EOF on jobserver pipe
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/run-make/overwrite-input/file.stderr b/tests/run-make/overwrite-input/file.stderr
index 9936962b4ee..c13a270b067 100644
--- a/tests/run-make/overwrite-input/file.stderr
+++ b/tests/run-make/overwrite-input/file.stderr
@@ -2,5 +2,5 @@ warning: ignoring --out-dir flag due to -o flag
 
 error: the input file "main.rs" would be overwritten by the generated executable
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/run-make/overwrite-input/folder.stderr b/tests/run-make/overwrite-input/folder.stderr
index 81b1e7367c7..6e51cb812ce 100644
--- a/tests/run-make/overwrite-input/folder.stderr
+++ b/tests/run-make/overwrite-input/folder.stderr
@@ -2,5 +2,5 @@ warning: ignoring --out-dir flag due to -o flag
 
 error: the generated executable for the input file "main.rs" conflicts with the existing directory "."
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/run-make/overwrite-input/main.stderr b/tests/run-make/overwrite-input/main.stderr
index 9936962b4ee..c13a270b067 100644
--- a/tests/run-make/overwrite-input/main.stderr
+++ b/tests/run-make/overwrite-input/main.stderr
@@ -2,5 +2,5 @@ warning: ignoring --out-dir flag due to -o flag
 
 error: the input file "main.rs" would be overwritten by the generated executable
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/run-make/unknown-mod-stdin/unknown-mod.stderr b/tests/run-make/unknown-mod-stdin/unknown-mod.stderr
index 81ff8393837..bdbaa381709 100644
--- a/tests/run-make/unknown-mod-stdin/unknown-mod.stderr
+++ b/tests/run-make/unknown-mod-stdin/unknown-mod.stderr
@@ -7,6 +7,6 @@ error[E0583]: file not found for module `unknown`
   = help: to create the module `unknown`, create file "unknown.rs" or "unknown/mod.rs"
   = note: if there is a `mod unknown` elsewhere in the crate already, import it with `use crate::...` instead
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0583`.

From 76a03132852b32e2427c17897393e52ae8bc0288 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 17:08:42 +0000
Subject: [PATCH 68/71] Bless clippy tests

Co-authored-by: Adrian <adrian.iosdev@gmail.com>
---
 src/tools/clippy/tests/ui-toml/bad_toml/conf_bad_toml.stderr    | 2 +-
 .../clippy/tests/ui-toml/bad_toml_type/conf_bad_type.stderr     | 2 +-
 .../ui-toml/conf_deprecated_key/conf_deprecated_key.stderr      | 2 +-
 .../decimal_literal_representation.stderr                       | 2 +-
 .../ui-toml/disallowed_names_replace/disallowed_names.stderr    | 2 +-
 .../disallowed_script_idents/disallowed_script_idents.stderr    | 2 +-
 .../tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr   | 2 +-
 .../clippy/tests/ui-toml/duplicated_keys/duplicated_keys.stderr | 2 +-
 .../ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr   | 2 +-
 .../ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr | 2 +-
 .../tests/ui-toml/enum_variant_size/enum_variant_size.stderr    | 2 +-
 .../clippy/tests/ui-toml/fn_params_excessive_bools/test.stderr  | 2 +-
 .../clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr     | 2 +-
 .../ui-toml/impl_trait_in_params/impl_trait_in_params.stderr    | 2 +-
 .../invalid_min_rust_version/invalid_min_rust_version.stderr    | 2 +-
 .../clippy/tests/ui-toml/large_futures/large_futures.stderr     | 2 +-
 .../tests/ui-toml/large_stack_frames/large_stack_frames.stderr  | 2 +-
 .../large_types_passed_by_value.stderr                          | 2 +-
 .../clippy/tests/ui-toml/manual_let_else/manual_let_else.stderr | 2 +-
 .../index_refutable_slice.stderr                                | 2 +-
 .../tests/ui-toml/min_rust_version/min_rust_version.stderr      | 2 +-
 .../tests/ui-toml/result_large_err/result_large_err.stderr      | 2 +-
 .../tests/ui-toml/semicolon_block/semicolon_inside_block.stderr | 2 +-
 .../clippy/tests/ui-toml/struct_excessive_bools/test.stderr     | 2 +-
 .../clippy/tests/ui-toml/too_large_for_stack/boxed_local.stderr | 2 +-
 .../clippy/tests/ui-toml/too_large_for_stack/useless_vec.stderr | 2 +-
 .../tests/ui-toml/too_many_arguments/too_many_arguments.stderr  | 2 +-
 .../clippy/tests/ui-toml/type_complexity/type_complexity.stderr | 2 +-
 .../clippy/tests/ui-toml/type_repetition_in_bounds/main.stderr  | 2 +-
 .../unnecessary_box_returns/unnecessary_box_returns.stderr      | 2 +-
 .../tests/ui-toml/verbose_bit_mask/verbose_bit_mask.stderr      | 2 +-
 .../tests/ui-toml/wildcard_imports/wildcard_imports.stderr      | 2 +-
 src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.stderr     | 2 +-
 src/tools/clippy/tests/ui/char_lit_as_u8.stderr                 | 2 +-
 src/tools/clippy/tests/ui/cognitive_complexity_attr_used.stderr | 2 +-
 src/tools/clippy/tests/ui/copy_iterator.stderr                  | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-10148.stderr              | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-11422.stderr              | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-2774.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-3717.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-3891.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-5497.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-5835.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-5872.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-6254.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-6255.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-6256.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-7169.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-7868.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-7869.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-8250.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-8821.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-9041.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-9445.stderr               | 2 +-
 src/tools/clippy/tests/ui/crashes/ice-96721.stderr              | 2 +-
 .../tests/ui/crashes/needless_lifetimes_impl_trait.stderr       | 2 +-
 .../tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr | 2 +-
 src/tools/clippy/tests/ui/crate_in_macro_def.stderr             | 2 +-
 src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.stderr | 2 +-
 .../tests/ui/crate_level_checks/std_main_recursion.stderr       | 2 +-
 src/tools/clippy/tests/ui/def_id_nocore.stderr                  | 2 +-
 src/tools/clippy/tests/ui/doc_link_with_quotes.stderr           | 2 +-
 src/tools/clippy/tests/ui/double_neg.stderr                     | 2 +-
 src/tools/clippy/tests/ui/duplicate_underscore_argument.stderr  | 2 +-
 src/tools/clippy/tests/ui/empty_enum.stderr                     | 2 +-
 src/tools/clippy/tests/ui/entry_btree.stderr                    | 2 +-
 src/tools/clippy/tests/ui/exit1.stderr                          | 2 +-
 src/tools/clippy/tests/ui/exit2.stderr                          | 2 +-
 src/tools/clippy/tests/ui/filter_map_next.stderr                | 2 +-
 .../clippy/tests/ui/four_forward_slashes_first_line.stderr      | 2 +-
 src/tools/clippy/tests/ui/functions_maxlines.stderr             | 2 +-
 .../ui/index_refutable_slice/slice_indexing_in_macro.stderr     | 2 +-
 src/tools/clippy/tests/ui/inspect_for_each.stderr               | 2 +-
 src/tools/clippy/tests/ui/issue-3145.stderr                     | 2 +-
 src/tools/clippy/tests/ui/issue_2356.stderr                     | 2 +-
 .../clippy/tests/ui/items_after_test_module/in_submodule.stderr | 2 +-
 .../clippy/tests/ui/items_after_test_module/root_module.stderr  | 2 +-
 src/tools/clippy/tests/ui/iter_next_loop.stderr                 | 2 +-
 src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr     | 2 +-
 src/tools/clippy/tests/ui/map_err.stderr                        | 2 +-
 src/tools/clippy/tests/ui/mem_replace_macro.stderr              | 2 +-
 src/tools/clippy/tests/ui/methods_fixable.stderr                | 2 +-
 src/tools/clippy/tests/ui/methods_unfixable.stderr              | 2 +-
 src/tools/clippy/tests/ui/missing_doc_crate_missing.stderr      | 2 +-
 src/tools/clippy/tests/ui/missing_spin_loop_no_std.stderr       | 2 +-
 src/tools/clippy/tests/ui/mut_mutex_lock.stderr                 | 2 +-
 .../tests/ui/needless_arbitrary_self_type_unfixable.stderr      | 2 +-
 src/tools/clippy/tests/ui/needless_bitwise_bool.stderr          | 2 +-
 src/tools/clippy/tests/ui/needless_else.stderr                  | 2 +-
 src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr    | 2 +-
 src/tools/clippy/tests/ui/needless_option_take.stderr           | 2 +-
 .../clippy/tests/ui/needless_return_with_question_mark.stderr   | 2 +-
 src/tools/clippy/tests/ui/needless_update.stderr                | 2 +-
 src/tools/clippy/tests/ui/new_ret_no_self_overflow.stderr       | 2 +-
 src/tools/clippy/tests/ui/non_minimal_cfg2.stderr               | 2 +-
 src/tools/clippy/tests/ui/obfuscated_if_else.stderr             | 2 +-
 src/tools/clippy/tests/ui/partialeq_ne_impl.stderr              | 2 +-
 src/tools/clippy/tests/ui/path_buf_push_overwrite.stderr        | 2 +-
 src/tools/clippy/tests/ui/permissions_set_readonly_false.stderr | 2 +-
 src/tools/clippy/tests/ui/proc_macro.stderr                     | 2 +-
 src/tools/clippy/tests/ui/pub_use.stderr                        | 2 +-
 src/tools/clippy/tests/ui/question_mark_used.stderr             | 2 +-
 src/tools/clippy/tests/ui/range.stderr                          | 2 +-
 src/tools/clippy/tests/ui/renamed_builtin_attr.stderr           | 2 +-
 src/tools/clippy/tests/ui/result_map_or_into_option.stderr      | 2 +-
 src/tools/clippy/tests/ui/seek_from_current.stderr              | 2 +-
 src/tools/clippy/tests/ui/self_named_constructors.stderr        | 2 +-
 src/tools/clippy/tests/ui/serde.stderr                          | 2 +-
 src/tools/clippy/tests/ui/should_panic_without_expect.stderr    | 2 +-
 src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr      | 2 +-
 src/tools/clippy/tests/ui/string_to_string.stderr               | 2 +-
 src/tools/clippy/tests/ui/tests_outside_test_module.stderr      | 2 +-
 src/tools/clippy/tests/ui/track-diagnostics.stderr              | 2 +-
 src/tools/clippy/tests/ui/types.stderr                          | 2 +-
 .../tests/ui/uninlined_format_args_panic.edition2018.stderr     | 2 +-
 src/tools/clippy/tests/ui/unknown_attribute.stderr              | 2 +-
 src/tools/clippy/tests/ui/vec_resize_to_zero.stderr             | 2 +-
 117 files changed, 117 insertions(+), 117 deletions(-)

diff --git a/src/tools/clippy/tests/ui-toml/bad_toml/conf_bad_toml.stderr b/src/tools/clippy/tests/ui-toml/bad_toml/conf_bad_toml.stderr
index f7d53763a43..c308b7aa023 100644
--- a/src/tools/clippy/tests/ui-toml/bad_toml/conf_bad_toml.stderr
+++ b/src/tools/clippy/tests/ui-toml/bad_toml/conf_bad_toml.stderr
@@ -4,5 +4,5 @@ error: error reading Clippy's configuration file: expected `.`, `=`
 LL | fn this_is_obviously(not: a, toml: file) {
    |    ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/bad_toml_type/conf_bad_type.stderr b/src/tools/clippy/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
index fb0a1408152..1bcde2f30ed 100644
--- a/src/tools/clippy/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
+++ b/src/tools/clippy/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
@@ -4,5 +4,5 @@ error: error reading Clippy's configuration file: invalid type: integer `42`, ex
 LL | disallowed-names = 42
    |                    ^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr b/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
index a21952c0e7a..08fdb2d2dc3 100644
--- a/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
+++ b/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
@@ -20,5 +20,5 @@ LL | fn cognitive_complexity() {
    = note: `-D clippy::cognitive-complexity` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cognitive_complexity)]`
 
-error: aborting due to previous error; 2 warnings emitted
+error: aborting due to 1 previous error; 2 warnings emitted
 
diff --git a/src/tools/clippy/tests/ui-toml/decimal_literal_representation/decimal_literal_representation.stderr b/src/tools/clippy/tests/ui-toml/decimal_literal_representation/decimal_literal_representation.stderr
index 6f817a3fdde..4510275c9a9 100644
--- a/src/tools/clippy/tests/ui-toml/decimal_literal_representation/decimal_literal_representation.stderr
+++ b/src/tools/clippy/tests/ui-toml/decimal_literal_representation/decimal_literal_representation.stderr
@@ -7,5 +7,5 @@ LL |     let _ = 16777215;
    = note: `-D clippy::decimal-literal-representation` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::decimal_literal_representation)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr b/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
index d9f25a3eee5..a5fece575f8 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
+++ b/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
@@ -7,5 +7,5 @@ LL |     let ducks = ["quack", "quack"];
    = note: `-D clippy::disallowed-names` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_names)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_script_idents/disallowed_script_idents.stderr b/src/tools/clippy/tests/ui-toml/disallowed_script_idents/disallowed_script_idents.stderr
index 31bb5ee3514..e83027e4e28 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_script_idents/disallowed_script_idents.stderr
+++ b/src/tools/clippy/tests/ui-toml/disallowed_script_idents/disallowed_script_idents.stderr
@@ -7,5 +7,5 @@ LL |     let カウンタ = 10;
    = note: `-D clippy::disallowed-script-idents` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_script_idents)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr b/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr
index 92b0350581d..877ca726fee 100644
--- a/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr
+++ b/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr
@@ -11,5 +11,5 @@ help: try
 LL | /// `TestItemThingyOfCoolness` might sound cool but is not on the list and should be linted.
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/duplicated_keys/duplicated_keys.stderr b/src/tools/clippy/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
index 7c56dfdb948..3f2086b5ecb 100644
--- a/src/tools/clippy/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
+++ b/src/tools/clippy/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
@@ -4,5 +4,5 @@ error: error reading Clippy's configuration file: duplicate key `cognitive-compl
 LL | cognitive-complexity-threshold = 4
    | ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr
index 0af8c0add6c..3c383963388 100644
--- a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr
+++ b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr
@@ -10,5 +10,5 @@ warning: error reading Clippy's configuration file: deprecated field `cyclomatic
 LL | cyclomatic-complexity-threshold = 3
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr
index a4b1e9c335c..3d37e4daa96 100644
--- a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr
+++ b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr
@@ -10,5 +10,5 @@ warning: error reading Clippy's configuration file: deprecated field `cyclomatic
 LL | cyclomatic-complexity-threshold = 3
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/src/tools/clippy/tests/ui-toml/enum_variant_size/enum_variant_size.stderr b/src/tools/clippy/tests/ui-toml/enum_variant_size/enum_variant_size.stderr
index 4d9bc9d48e4..ca96c47b92b 100644
--- a/src/tools/clippy/tests/ui-toml/enum_variant_size/enum_variant_size.stderr
+++ b/src/tools/clippy/tests/ui-toml/enum_variant_size/enum_variant_size.stderr
@@ -17,5 +17,5 @@ help: consider boxing the large fields to reduce the total size of the enum
 LL |     B(Box<[u8; 501]>),
    |       ~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.stderr b/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.stderr
index 717a4bbfbfe..ceec4ea6755 100644
--- a/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.stderr
@@ -8,5 +8,5 @@ LL | fn g(_: bool, _: bool) {}
    = note: `-D clippy::fn-params-excessive-bools` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::fn_params_excessive_bools)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr b/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr
index 305e00af27e..e0e77bf23f6 100644
--- a/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr
+++ b/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr
@@ -12,5 +12,5 @@ LL |     if x.get() {
    = note: `-D clippy::ifs-same-cond` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::ifs_same_cond)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr b/src/tools/clippy/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr
index 80c4f5ed4b0..bb1244ada9f 100644
--- a/src/tools/clippy/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr
+++ b/src/tools/clippy/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr
@@ -11,5 +11,5 @@ help: add a type parameter
 LL |     fn t<{ /* Generic name */ }: Trait>(_: impl Trait);
    |         +++++++++++++++++++++++++++++++
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr b/src/tools/clippy/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
index f127c2408f9..a764840665a 100644
--- a/src/tools/clippy/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
+++ b/src/tools/clippy/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
@@ -4,5 +4,5 @@ error: error reading Clippy's configuration file: not a valid Rust version
 LL | msrv = "invalid.version"
    |        ^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/large_futures/large_futures.stderr b/src/tools/clippy/tests/ui-toml/large_futures/large_futures.stderr
index 7a02fcdbdd2..23c6215f949 100644
--- a/src/tools/clippy/tests/ui-toml/large_futures/large_futures.stderr
+++ b/src/tools/clippy/tests/ui-toml/large_futures/large_futures.stderr
@@ -7,5 +7,5 @@ LL |     should_warn().await;
    = note: `-D clippy::large-futures` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::large_futures)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/large_stack_frames/large_stack_frames.stderr b/src/tools/clippy/tests/ui-toml/large_stack_frames/large_stack_frames.stderr
index 67ee57ab672..5adf666278f 100644
--- a/src/tools/clippy/tests/ui-toml/large_stack_frames/large_stack_frames.stderr
+++ b/src/tools/clippy/tests/ui-toml/large_stack_frames/large_stack_frames.stderr
@@ -11,5 +11,5 @@ LL | | }
    = note: `-D clippy::large-stack-frames` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::large_stack_frames)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/large_types_passed_by_value/large_types_passed_by_value.stderr b/src/tools/clippy/tests/ui-toml/large_types_passed_by_value/large_types_passed_by_value.stderr
index 6678a2b4721..20026d358ae 100644
--- a/src/tools/clippy/tests/ui-toml/large_types_passed_by_value/large_types_passed_by_value.stderr
+++ b/src/tools/clippy/tests/ui-toml/large_types_passed_by_value/large_types_passed_by_value.stderr
@@ -7,5 +7,5 @@ LL | fn f2(_v: [u8; 513]) {}
    = note: `-D clippy::large-types-passed-by-value` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::large_types_passed_by_value)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/manual_let_else/manual_let_else.stderr b/src/tools/clippy/tests/ui-toml/manual_let_else/manual_let_else.stderr
index 5c2c86c3731..67647cc5e95 100644
--- a/src/tools/clippy/tests/ui-toml/manual_let_else/manual_let_else.stderr
+++ b/src/tools/clippy/tests/ui-toml/manual_let_else/manual_let_else.stderr
@@ -11,5 +11,5 @@ LL | |     };
    = note: `-D clippy::manual-let-else` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::manual_let_else)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr b/src/tools/clippy/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
index d319e65d06c..20ffacd092a 100644
--- a/src/tools/clippy/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
+++ b/src/tools/clippy/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
@@ -18,5 +18,5 @@ help: and replace the index expressions here
 LL |         println!("{}", slice_7);
    |                        ~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.stderr b/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.stderr
index 5b1f8dbd3ea..5bf2bcd3bc6 100644
--- a/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.stderr
+++ b/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.stderr
@@ -7,5 +7,5 @@ LL |     let _: Option<u64> = Some(&16).map(|b| *b);
    = note: `-D clippy::map-clone` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::map_clone)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/result_large_err/result_large_err.stderr b/src/tools/clippy/tests/ui-toml/result_large_err/result_large_err.stderr
index b0936319d1b..cc603fc0cc0 100644
--- a/src/tools/clippy/tests/ui-toml/result_large_err/result_large_err.stderr
+++ b/src/tools/clippy/tests/ui-toml/result_large_err/result_large_err.stderr
@@ -8,5 +8,5 @@ LL | fn f2() -> Result<(), [u8; 512]> {
    = note: `-D clippy::result-large-err` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::result_large_err)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
index ce03d7d75a2..0542e139b34 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
@@ -15,5 +15,5 @@ LL ~         unit_fn_block();
 LL ~     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr b/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr
index 9237c9c9d29..31e0e33a39b 100644
--- a/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr
@@ -10,5 +10,5 @@ LL | | }
    = note: `-D clippy::struct-excessive-bools` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::struct_excessive_bools)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/too_large_for_stack/boxed_local.stderr b/src/tools/clippy/tests/ui-toml/too_large_for_stack/boxed_local.stderr
index 2859a29f1b2..54990c35228 100644
--- a/src/tools/clippy/tests/ui-toml/too_large_for_stack/boxed_local.stderr
+++ b/src/tools/clippy/tests/ui-toml/too_large_for_stack/boxed_local.stderr
@@ -7,5 +7,5 @@ LL | fn f(x: Box<[u8; 500]>) {}
    = note: `-D clippy::boxed-local` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::boxed_local)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/too_large_for_stack/useless_vec.stderr b/src/tools/clippy/tests/ui-toml/too_large_for_stack/useless_vec.stderr
index 923cded5eef..5d289db8534 100644
--- a/src/tools/clippy/tests/ui-toml/too_large_for_stack/useless_vec.stderr
+++ b/src/tools/clippy/tests/ui-toml/too_large_for_stack/useless_vec.stderr
@@ -7,5 +7,5 @@ LL |     let x = vec![0u8; 500];
    = note: `-D clippy::useless-vec` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::useless_vec)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/too_many_arguments/too_many_arguments.stderr b/src/tools/clippy/tests/ui-toml/too_many_arguments/too_many_arguments.stderr
index 8b9d159b59c..81d9bee737e 100644
--- a/src/tools/clippy/tests/ui-toml/too_many_arguments/too_many_arguments.stderr
+++ b/src/tools/clippy/tests/ui-toml/too_many_arguments/too_many_arguments.stderr
@@ -7,5 +7,5 @@ LL | fn too_many(p1: u8, p2: u8, p3: u8, p4: u8, p5: u8, p6: u8, p7: u8, p8: u8,
    = note: `-D clippy::too-many-arguments` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::too_many_arguments)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/type_complexity/type_complexity.stderr b/src/tools/clippy/tests/ui-toml/type_complexity/type_complexity.stderr
index 8ca637f7222..df824400da8 100644
--- a/src/tools/clippy/tests/ui-toml/type_complexity/type_complexity.stderr
+++ b/src/tools/clippy/tests/ui-toml/type_complexity/type_complexity.stderr
@@ -7,5 +7,5 @@ LL | fn f2(_: (u8, (u8, (u8, (u8, (u8, (u8, u8))))))) {}
    = note: `-D clippy::type-complexity` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::type_complexity)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/type_repetition_in_bounds/main.stderr b/src/tools/clippy/tests/ui-toml/type_repetition_in_bounds/main.stderr
index 2ae2984975f..444fbd12814 100644
--- a/src/tools/clippy/tests/ui-toml/type_repetition_in_bounds/main.stderr
+++ b/src/tools/clippy/tests/ui-toml/type_repetition_in_bounds/main.stderr
@@ -8,5 +8,5 @@ LL |     T: Unpin + PartialEq,
    = note: `-D clippy::type-repetition-in-bounds` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::type_repetition_in_bounds)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/unnecessary_box_returns/unnecessary_box_returns.stderr b/src/tools/clippy/tests/ui-toml/unnecessary_box_returns/unnecessary_box_returns.stderr
index df9aa37ac10..9a747a19f79 100644
--- a/src/tools/clippy/tests/ui-toml/unnecessary_box_returns/unnecessary_box_returns.stderr
+++ b/src/tools/clippy/tests/ui-toml/unnecessary_box_returns/unnecessary_box_returns.stderr
@@ -8,5 +8,5 @@ LL | fn f() -> Box<[u8; 64]> {
    = note: `-D clippy::unnecessary-box-returns` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_box_returns)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/verbose_bit_mask/verbose_bit_mask.stderr b/src/tools/clippy/tests/ui-toml/verbose_bit_mask/verbose_bit_mask.stderr
index 7377921b42a..5fcc63131bf 100644
--- a/src/tools/clippy/tests/ui-toml/verbose_bit_mask/verbose_bit_mask.stderr
+++ b/src/tools/clippy/tests/ui-toml/verbose_bit_mask/verbose_bit_mask.stderr
@@ -7,5 +7,5 @@ LL |     let _ = v & 0b111111 == 0;
    = note: `-D clippy::verbose-bit-mask` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::verbose_bit_mask)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/wildcard_imports/wildcard_imports.stderr b/src/tools/clippy/tests/ui-toml/wildcard_imports/wildcard_imports.stderr
index 13ec3a229ce..f11fda6a0c6 100644
--- a/src/tools/clippy/tests/ui-toml/wildcard_imports/wildcard_imports.stderr
+++ b/src/tools/clippy/tests/ui-toml/wildcard_imports/wildcard_imports.stderr
@@ -7,5 +7,5 @@ LL | use prelude::*;
    = note: `-D clippy::wildcard-imports` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::wildcard_imports)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.stderr b/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.stderr
index 2a21f5ca236..296af643693 100644
--- a/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.stderr
@@ -15,5 +15,5 @@ help: if you would like to deref, try using `&**`
 LL |         let x: &str = &**s;
    |                       ~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/char_lit_as_u8.stderr b/src/tools/clippy/tests/ui/char_lit_as_u8.stderr
index ce1f2f8296e..22774d2f9f6 100644
--- a/src/tools/clippy/tests/ui/char_lit_as_u8.stderr
+++ b/src/tools/clippy/tests/ui/char_lit_as_u8.stderr
@@ -8,5 +8,5 @@ LL |     let _ = '❤' as u8;
    = note: `-D clippy::char-lit-as-u8` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::char_lit_as_u8)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.stderr b/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.stderr
index 9cd25f6fda9..b9af72371e6 100644
--- a/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.stderr
+++ b/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.stderr
@@ -8,5 +8,5 @@ LL | fn kaboom() {
    = note: `-D clippy::cognitive-complexity` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cognitive_complexity)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/copy_iterator.stderr b/src/tools/clippy/tests/ui/copy_iterator.stderr
index 48c3385b6c8..30535db50cc 100644
--- a/src/tools/clippy/tests/ui/copy_iterator.stderr
+++ b/src/tools/clippy/tests/ui/copy_iterator.stderr
@@ -14,5 +14,5 @@ LL | | }
    = note: `-D clippy::copy-iterator` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::copy_iterator)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-10148.stderr b/src/tools/clippy/tests/ui/crashes/ice-10148.stderr
index 4d436e3aa04..ece3e1c3940 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-10148.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-10148.stderr
@@ -9,5 +9,5 @@ LL |     println!(with_span!(""something ""));
    = note: `-D clippy::println-empty-string` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::println_empty_string)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11422.stderr b/src/tools/clippy/tests/ui/crashes/ice-11422.stderr
index fb80b5b147f..b3dcc00f3d9 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11422.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-11422.stderr
@@ -12,5 +12,5 @@ LL - fn gen() -> impl PartialOrd + PartialEq + Debug {}
 LL + fn gen() -> impl PartialOrd + Debug {}
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2774.stderr b/src/tools/clippy/tests/ui/crashes/ice-2774.stderr
index ae9610c9acd..188a5985024 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2774.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-2774.stderr
@@ -12,5 +12,5 @@ LL - pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
 LL + pub fn add_barfoos_to_foos(bars: &HashSet<&Bar>) {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3717.stderr b/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
index 4d3d617b693..863608fca8b 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
@@ -18,5 +18,5 @@ help: ...and use generic constructor
 LL |     let _: HashSet<usize> = HashSet::default();
    |                             ~~~~~~~~~~~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3891.stderr b/src/tools/clippy/tests/ui/crashes/ice-3891.stderr
index 59469ec5891..5358734fed0 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3891.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-3891.stderr
@@ -6,5 +6,5 @@ LL |     1x;
    |
    = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5497.stderr b/src/tools/clippy/tests/ui/crashes/ice-5497.stderr
index e75e7dc9136..ee69f3379b6 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5497.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-5497.stderr
@@ -6,5 +6,5 @@ LL |     const OOB: i32 = [1][1] + T::OOB;
    |
    = note: `#[deny(unconditional_panic)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5835.stderr b/src/tools/clippy/tests/ui/crashes/ice-5835.stderr
index 74d99a34847..1f930e1f6d2 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5835.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-5835.stderr
@@ -7,5 +7,5 @@ LL |     /// 位
    = note: `-D clippy::tabs-in-doc-comments` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::tabs_in_doc_comments)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5872.stderr b/src/tools/clippy/tests/ui/crashes/ice-5872.stderr
index 75a26ee318c..d0067a2239e 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5872.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-5872.stderr
@@ -7,5 +7,5 @@ LL |     let _ = vec![1, 2, 3].into_iter().collect::<Vec<_>>().is_empty();
    = note: `-D clippy::needless-collect` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_collect)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6254.stderr b/src/tools/clippy/tests/ui/crashes/ice-6254.stderr
index 6ace7dae8bd..7a34e6cceee 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6254.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-6254.stderr
@@ -11,5 +11,5 @@ LL |         FOO_REF_REF => {},
    = note: `-D indirect-structural-match` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(indirect_structural_match)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6255.stderr b/src/tools/clippy/tests/ui/crashes/ice-6255.stderr
index db0cb25e34a..bc13319bef0 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6255.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-6255.stderr
@@ -9,5 +9,5 @@ LL | define_other_core!();
    |
    = note: this error originates in the macro `define_other_core` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6256.stderr b/src/tools/clippy/tests/ui/crashes/ice-6256.stderr
index 671933157c8..cba6df194ec 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6256.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-6256.stderr
@@ -9,6 +9,6 @@ LL |     let f = |x: &dyn TT| x.func();
    |              |  let's call the lifetime of this reference `'1`
    |              `x` is a reference that is only valid in the closure body
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0521`.
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7169.stderr b/src/tools/clippy/tests/ui/crashes/ice-7169.stderr
index 47947f89baf..3126de93d22 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7169.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-7169.stderr
@@ -7,5 +7,5 @@ LL |     if let Ok(_) = Ok::<_, ()>(A::<String>::default()) {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7868.stderr b/src/tools/clippy/tests/ui/crashes/ice-7868.stderr
index e5f14f2215d..3315a8d907a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7868.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-7868.stderr
@@ -8,5 +8,5 @@ LL |     unsafe { 0 };
    = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7869.stderr b/src/tools/clippy/tests/ui/crashes/ice-7869.stderr
index 7acace78a7b..22f2c7e46fd 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7869.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-7869.stderr
@@ -13,5 +13,5 @@ LL | | }
    = note: `-D clippy::enum-variant-names` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::enum_variant_names)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8250.stderr b/src/tools/clippy/tests/ui/crashes/ice-8250.stderr
index 9c57f334581..397e978af0b 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8250.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-8250.stderr
@@ -7,5 +7,5 @@ LL |     let _ = s[1..].splitn(2, '.').next()?;
    = note: `-D clippy::needless-splitn` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_splitn)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8821.stderr b/src/tools/clippy/tests/ui/crashes/ice-8821.stderr
index c8bd01fb1c6..94ebb20918e 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8821.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-8821.stderr
@@ -7,5 +7,5 @@ LL |     let _: () = FN();
    = note: `-D clippy::let-unit-value` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::let_unit_value)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9041.stderr b/src/tools/clippy/tests/ui/crashes/ice-9041.stderr
index 49c9bdc300e..00b65f00d78 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9041.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-9041.stderr
@@ -7,5 +7,5 @@ LL |     things.iter().find(|p| is_thing_ready(p)).is_some()
    = note: `-D clippy::search-is-some` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::search_is_some)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9445.stderr b/src/tools/clippy/tests/ui/crashes/ice-9445.stderr
index 9307409ba58..f97b4536e12 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9445.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-9445.stderr
@@ -9,5 +9,5 @@ LL | const UNINIT: core::mem::MaybeUninit<core::cell::Cell<&'static ()>> = core:
    = note: `-D clippy::declare-interior-mutable-const` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::declare_interior_mutable_const)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-96721.stderr b/src/tools/clippy/tests/ui/crashes/ice-96721.stderr
index 712bd14c685..1741c7c6a0a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-96721.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-96721.stderr
@@ -4,5 +4,5 @@ error: malformed `path` attribute input
 LL | #[path = foo!()]
    | ^^^^^^^^^^^^^^^^ help: must be of the form: `#[path = "file"]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr b/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
index 37484f5ebd7..2ebb9d5cd1a 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
+++ b/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
@@ -15,5 +15,5 @@ LL -     fn baz<'a>(&'a self) -> impl Foo + 'a {
 LL +     fn baz(&self) -> impl Foo + '_ {
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr b/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr
index 6d45393996d..b318f8d3f7a 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr
+++ b/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr
@@ -12,5 +12,5 @@ LL | struct Foo<'a>(&'a [(); 100]);
    = note: `-D clippy::needless-pass-by-value` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_pass_by_value)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crate_in_macro_def.stderr b/src/tools/clippy/tests/ui/crate_in_macro_def.stderr
index 3e624618237..1a21d4e92f2 100644
--- a/src/tools/clippy/tests/ui/crate_in_macro_def.stderr
+++ b/src/tools/clippy/tests/ui/crate_in_macro_def.stderr
@@ -7,5 +7,5 @@ LL |             println!("{}", crate::unhygienic::MESSAGE);
    = note: `-D clippy::crate-in-macro-def` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::crate_in_macro_def)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.stderr b/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.stderr
index 01033246dd9..7ef8d08d5d6 100644
--- a/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.stderr
+++ b/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.stderr
@@ -11,5 +11,5 @@ LL | |     b = a;
    = note: `-D clippy::almost-swapped` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::almost_swapped)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.stderr b/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.stderr
index f3ffd6a10c7..3bc406206e4 100644
--- a/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.stderr
+++ b/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.stderr
@@ -8,5 +8,5 @@ LL |     main();
    = note: `-D clippy::main-recursion` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::main_recursion)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/def_id_nocore.stderr b/src/tools/clippy/tests/ui/def_id_nocore.stderr
index bfd0de4e13a..6a00331ec69 100644
--- a/src/tools/clippy/tests/ui/def_id_nocore.stderr
+++ b/src/tools/clippy/tests/ui/def_id_nocore.stderr
@@ -8,5 +8,5 @@ LL |     pub fn as_ref(self) -> &'static str {
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::wrong_self_convention)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr b/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr
index 2db1bc09289..e1883f349b0 100644
--- a/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr
+++ b/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr
@@ -7,5 +7,5 @@ LL | /// Calls ['bar'] uselessly
    = note: `-D clippy::doc-link-with-quotes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::doc_link_with_quotes)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/double_neg.stderr b/src/tools/clippy/tests/ui/double_neg.stderr
index a6241c78610..a4fa1688d57 100644
--- a/src/tools/clippy/tests/ui/double_neg.stderr
+++ b/src/tools/clippy/tests/ui/double_neg.stderr
@@ -7,5 +7,5 @@ LL |     --x;
    = note: `-D clippy::double-neg` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::double_neg)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/duplicate_underscore_argument.stderr b/src/tools/clippy/tests/ui/duplicate_underscore_argument.stderr
index f47f6c89622..53ee0c4e8c8 100644
--- a/src/tools/clippy/tests/ui/duplicate_underscore_argument.stderr
+++ b/src/tools/clippy/tests/ui/duplicate_underscore_argument.stderr
@@ -7,5 +7,5 @@ LL | fn join_the_dark_side(darth: i32, _darth: i32) {}
    = note: `-D clippy::duplicate-underscore-argument` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::duplicate_underscore_argument)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/empty_enum.stderr b/src/tools/clippy/tests/ui/empty_enum.stderr
index 92d81c7269a..c9bd887643e 100644
--- a/src/tools/clippy/tests/ui/empty_enum.stderr
+++ b/src/tools/clippy/tests/ui/empty_enum.stderr
@@ -8,5 +8,5 @@ LL | enum Empty {}
    = note: `-D clippy::empty-enum` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::empty_enum)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/entry_btree.stderr b/src/tools/clippy/tests/ui/entry_btree.stderr
index cc0e951d9b4..63e9a0af8b6 100644
--- a/src/tools/clippy/tests/ui/entry_btree.stderr
+++ b/src/tools/clippy/tests/ui/entry_btree.stderr
@@ -17,5 +17,5 @@ LL +         foo();
 LL +     }
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/exit1.stderr b/src/tools/clippy/tests/ui/exit1.stderr
index 94d8f1e32ee..bbe0762c8d1 100644
--- a/src/tools/clippy/tests/ui/exit1.stderr
+++ b/src/tools/clippy/tests/ui/exit1.stderr
@@ -7,5 +7,5 @@ LL |         std::process::exit(4);
    = note: `-D clippy::exit` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::exit)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/exit2.stderr b/src/tools/clippy/tests/ui/exit2.stderr
index cd324f18220..19abbc6062a 100644
--- a/src/tools/clippy/tests/ui/exit2.stderr
+++ b/src/tools/clippy/tests/ui/exit2.stderr
@@ -7,5 +7,5 @@ LL |     std::process::exit(3);
    = note: `-D clippy::exit` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::exit)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/filter_map_next.stderr b/src/tools/clippy/tests/ui/filter_map_next.stderr
index 1841553917f..07760d8837a 100644
--- a/src/tools/clippy/tests/ui/filter_map_next.stderr
+++ b/src/tools/clippy/tests/ui/filter_map_next.stderr
@@ -14,5 +14,5 @@ LL | |         .next();
    = note: `-D clippy::filter-map-next` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::filter_map_next)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr
index afb7c6b4dbd..f49b7a0977f 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr
+++ b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr
@@ -12,5 +12,5 @@ help: make this a doc comment by removing one `/`
 LL + /// borked doc comment on the first line. doesn't combust!
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/functions_maxlines.stderr b/src/tools/clippy/tests/ui/functions_maxlines.stderr
index 1d6ddad79ff..497acc0a65e 100644
--- a/src/tools/clippy/tests/ui/functions_maxlines.stderr
+++ b/src/tools/clippy/tests/ui/functions_maxlines.stderr
@@ -13,5 +13,5 @@ LL | | }
    = note: `-D clippy::too-many-lines` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::too_many_lines)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr b/src/tools/clippy/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr
index 11b19428b4f..429861e993e 100644
--- a/src/tools/clippy/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr
+++ b/src/tools/clippy/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr
@@ -18,5 +18,5 @@ help: and replace the index expressions here
 LL |             println!("{}", slice_0);
    |                            ~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/inspect_for_each.stderr b/src/tools/clippy/tests/ui/inspect_for_each.stderr
index 80df86ad64e..8bd4fe3987c 100644
--- a/src/tools/clippy/tests/ui/inspect_for_each.stderr
+++ b/src/tools/clippy/tests/ui/inspect_for_each.stderr
@@ -14,5 +14,5 @@ LL | |     });
    = note: `-D clippy::inspect-for-each` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::inspect_for_each)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/issue-3145.stderr b/src/tools/clippy/tests/ui/issue-3145.stderr
index d7c2c88a204..51debc9b72f 100644
--- a/src/tools/clippy/tests/ui/issue-3145.stderr
+++ b/src/tools/clippy/tests/ui/issue-3145.stderr
@@ -4,5 +4,5 @@ error: expected `,`, found `a`
 LL |     println!("{}" a);
    |                   ^ expected `,`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/issue_2356.stderr b/src/tools/clippy/tests/ui/issue_2356.stderr
index d04b49e52a5..860c545c7b8 100644
--- a/src/tools/clippy/tests/ui/issue_2356.stderr
+++ b/src/tools/clippy/tests/ui/issue_2356.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(clippy::while_let_on_iterator)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.stderr b/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.stderr
index 4e99876365c..30aa90d29bf 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.stderr
+++ b/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.stderr
@@ -10,5 +10,5 @@ LL | fn in_submodule() {}
    = note: `-D clippy::items-after-test-module` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::items_after_test_module)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/root_module.stderr b/src/tools/clippy/tests/ui/items_after_test_module/root_module.stderr
index 67bc82ebff9..17b07cc32f4 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/root_module.stderr
+++ b/src/tools/clippy/tests/ui/items_after_test_module/root_module.stderr
@@ -16,5 +16,5 @@ LL | macro_rules! should_lint {
    = help: to override `-D warnings` add `#[allow(clippy::items_after_test_module)]`
    = help: move the items to before the test module was defined
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/iter_next_loop.stderr b/src/tools/clippy/tests/ui/iter_next_loop.stderr
index 5bba0e635bb..5871d21e491 100644
--- a/src/tools/clippy/tests/ui/iter_next_loop.stderr
+++ b/src/tools/clippy/tests/ui/iter_next_loop.stderr
@@ -4,6 +4,6 @@ error[E0423]: expected value, found macro `vec`
 LL |     for _ in vec.iter().next() {}
    |              ^^^ not a value
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr b/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr
index 7361a4a2cbb..d2922af99bf 100644
--- a/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr
+++ b/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr
@@ -22,5 +22,5 @@ LL |     _C,
    = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::manual_non_exhaustive)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/map_err.stderr b/src/tools/clippy/tests/ui/map_err.stderr
index 6a845c84a2a..eb6742ff233 100644
--- a/src/tools/clippy/tests/ui/map_err.stderr
+++ b/src/tools/clippy/tests/ui/map_err.stderr
@@ -8,5 +8,5 @@ LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
    = note: `-D clippy::map-err-ignore` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::map_err_ignore)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/mem_replace_macro.stderr b/src/tools/clippy/tests/ui/mem_replace_macro.stderr
index 842ad3a8565..c6435e94e96 100644
--- a/src/tools/clippy/tests/ui/mem_replace_macro.stderr
+++ b/src/tools/clippy/tests/ui/mem_replace_macro.stderr
@@ -8,5 +8,5 @@ LL |     inline!(std::mem::replace($s, Default::default()));
    = help: to override `-D warnings` add `#[allow(clippy::mem_replace_with_default)]`
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/methods_fixable.stderr b/src/tools/clippy/tests/ui/methods_fixable.stderr
index 1bfe56d912b..f290c20e5e9 100644
--- a/src/tools/clippy/tests/ui/methods_fixable.stderr
+++ b/src/tools/clippy/tests/ui/methods_fixable.stderr
@@ -7,5 +7,5 @@ LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    = note: `-D clippy::filter-next` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::filter_next)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/methods_unfixable.stderr b/src/tools/clippy/tests/ui/methods_unfixable.stderr
index 581a985e0b5..771e10cbe10 100644
--- a/src/tools/clippy/tests/ui/methods_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/methods_unfixable.stderr
@@ -12,5 +12,5 @@ LL |     let iter = (0..10);
    = note: `-D clippy::filter-next` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::filter_next)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/missing_doc_crate_missing.stderr b/src/tools/clippy/tests/ui/missing_doc_crate_missing.stderr
index c684bc8e707..3aa9781c2f1 100644
--- a/src/tools/clippy/tests/ui/missing_doc_crate_missing.stderr
+++ b/src/tools/clippy/tests/ui/missing_doc_crate_missing.stderr
@@ -11,5 +11,5 @@ LL | | fn main() {}
    = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::missing_docs_in_private_items)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/missing_spin_loop_no_std.stderr b/src/tools/clippy/tests/ui/missing_spin_loop_no_std.stderr
index 0b7be461651..d84d06088ba 100644
--- a/src/tools/clippy/tests/ui/missing_spin_loop_no_std.stderr
+++ b/src/tools/clippy/tests/ui/missing_spin_loop_no_std.stderr
@@ -7,5 +7,5 @@ LL |     while b.load(Ordering::Acquire) {}
    = note: `-D clippy::missing-spin-loop` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::missing_spin_loop)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/mut_mutex_lock.stderr b/src/tools/clippy/tests/ui/mut_mutex_lock.stderr
index 9b20016be79..81960288276 100644
--- a/src/tools/clippy/tests/ui/mut_mutex_lock.stderr
+++ b/src/tools/clippy/tests/ui/mut_mutex_lock.stderr
@@ -7,5 +7,5 @@ LL |     let mut value = value_mutex.lock().unwrap();
    = note: `-D clippy::mut-mutex-lock` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mut_mutex_lock)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.stderr b/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.stderr
index 183e2dbc8c1..e91359a3cc1 100644
--- a/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.stderr
@@ -7,5 +7,5 @@ LL |         fn call_with_mut_self(self: &mut Self) {}
    = note: `-D clippy::needless-arbitrary-self-type` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_arbitrary_self_type)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr b/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr
index 2ed9208e623..b1fc1a7a958 100644
--- a/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr
+++ b/src/tools/clippy/tests/ui/needless_bitwise_bool.stderr
@@ -7,5 +7,5 @@ LL |     if y & !x {
    = note: `-D clippy::needless-bitwise-bool` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_bitwise_bool)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_else.stderr b/src/tools/clippy/tests/ui/needless_else.stderr
index e6f7138e948..66552109c48 100644
--- a/src/tools/clippy/tests/ui/needless_else.stderr
+++ b/src/tools/clippy/tests/ui/needless_else.stderr
@@ -9,5 +9,5 @@ LL | |     }
    = note: `-D clippy::needless-else` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_else)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr b/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr
index 73f249ae6c2..24a22e23248 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr
@@ -29,5 +29,5 @@ help: ...and replace `return` with `continue`
 LL |             continue;
    |             ~~~~~~~~
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_option_take.stderr b/src/tools/clippy/tests/ui/needless_option_take.stderr
index d3c22441d00..bf43a18e711 100644
--- a/src/tools/clippy/tests/ui/needless_option_take.stderr
+++ b/src/tools/clippy/tests/ui/needless_option_take.stderr
@@ -7,5 +7,5 @@ LL |     x.as_ref().take();
    = note: `-D clippy::needless-option-take` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_option_take)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr b/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr
index 580970a41aa..707f1c25327 100644
--- a/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr
+++ b/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr
@@ -7,5 +7,5 @@ LL |     return Err(())?;
    = note: `-D clippy::needless-return-with-question-mark` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_return_with_question_mark)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/needless_update.stderr b/src/tools/clippy/tests/ui/needless_update.stderr
index 3e9e2941a7a..60aeb049387 100644
--- a/src/tools/clippy/tests/ui/needless_update.stderr
+++ b/src/tools/clippy/tests/ui/needless_update.stderr
@@ -7,5 +7,5 @@ LL |     S { a: 1, b: 1, ..base };
    = note: `-D clippy::needless-update` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_update)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/new_ret_no_self_overflow.stderr b/src/tools/clippy/tests/ui/new_ret_no_self_overflow.stderr
index babb634fdcd..c0d6a74a51d 100644
--- a/src/tools/clippy/tests/ui/new_ret_no_self_overflow.stderr
+++ b/src/tools/clippy/tests/ui/new_ret_no_self_overflow.stderr
@@ -4,6 +4,6 @@ error[E0275]: overflow evaluating the requirement `<i32 as std::ops::Add>::Outpu
 LL |         pub fn new() -> X {
    |                         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr b/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr
index 001fcddd906..036d38c22f4 100644
--- a/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr
+++ b/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr
@@ -7,5 +7,5 @@ LL | #[cfg(all())]
    = note: `-D clippy::non-minimal-cfg` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::non_minimal_cfg)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/obfuscated_if_else.stderr b/src/tools/clippy/tests/ui/obfuscated_if_else.stderr
index ca9f5e1e374..abf5adce444 100644
--- a/src/tools/clippy/tests/ui/obfuscated_if_else.stderr
+++ b/src/tools/clippy/tests/ui/obfuscated_if_else.stderr
@@ -7,5 +7,5 @@ LL |     true.then_some("a").unwrap_or("b");
    = note: `-D clippy::obfuscated-if-else` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::obfuscated_if_else)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr b/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
index 163d6b1dd7b..2210e706d93 100644
--- a/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
+++ b/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
@@ -11,5 +11,5 @@ LL | |     }
    = note: `-D clippy::partialeq-ne-impl` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::partialeq_ne_impl)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/path_buf_push_overwrite.stderr b/src/tools/clippy/tests/ui/path_buf_push_overwrite.stderr
index 1453d020c41..f96ce0de779 100644
--- a/src/tools/clippy/tests/ui/path_buf_push_overwrite.stderr
+++ b/src/tools/clippy/tests/ui/path_buf_push_overwrite.stderr
@@ -7,5 +7,5 @@ LL |     x.push("/bar");
    = note: `-D clippy::path-buf-push-overwrite` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::path_buf_push_overwrite)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/permissions_set_readonly_false.stderr b/src/tools/clippy/tests/ui/permissions_set_readonly_false.stderr
index 58a7de84d8f..bd34463084a 100644
--- a/src/tools/clippy/tests/ui/permissions_set_readonly_false.stderr
+++ b/src/tools/clippy/tests/ui/permissions_set_readonly_false.stderr
@@ -10,5 +10,5 @@ LL |     permissions.set_readonly(false);
    = note: `-D clippy::permissions-set-readonly-false` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::permissions_set_readonly_false)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/proc_macro.stderr b/src/tools/clippy/tests/ui/proc_macro.stderr
index d912b502755..122374ea804 100644
--- a/src/tools/clippy/tests/ui/proc_macro.stderr
+++ b/src/tools/clippy/tests/ui/proc_macro.stderr
@@ -7,5 +7,5 @@ LL |     let _x = 3.14;
    = help: consider using the constant directly
    = note: `#[deny(clippy::approx_constant)]` on by default
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/pub_use.stderr b/src/tools/clippy/tests/ui/pub_use.stderr
index 78157273664..f6f5db9a180 100644
--- a/src/tools/clippy/tests/ui/pub_use.stderr
+++ b/src/tools/clippy/tests/ui/pub_use.stderr
@@ -8,5 +8,5 @@ LL |     pub use inner::Test;
    = note: `-D clippy::pub-use` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::pub_use)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/question_mark_used.stderr b/src/tools/clippy/tests/ui/question_mark_used.stderr
index a3f440de80a..b4e256ddb9e 100644
--- a/src/tools/clippy/tests/ui/question_mark_used.stderr
+++ b/src/tools/clippy/tests/ui/question_mark_used.stderr
@@ -8,5 +8,5 @@ LL |     other_function()?;
    = note: `-D clippy::question-mark-used` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::question_mark_used)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/range.stderr b/src/tools/clippy/tests/ui/range.stderr
index 9f174307b82..78ef17b5ba7 100644
--- a/src/tools/clippy/tests/ui/range.stderr
+++ b/src/tools/clippy/tests/ui/range.stderr
@@ -7,5 +7,5 @@ LL |     let _x = v1.iter().zip(0..v1.len());
    = note: `-D clippy::range-zip-with-len` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::range_zip_with_len)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr b/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr
index 636d88fcd69..662188bbabc 100644
--- a/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr
+++ b/src/tools/clippy/tests/ui/renamed_builtin_attr.stderr
@@ -4,5 +4,5 @@ error: usage of deprecated attribute
 LL | #[clippy::cyclomatic_complexity = "1"]
    |           ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `cognitive_complexity`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/result_map_or_into_option.stderr b/src/tools/clippy/tests/ui/result_map_or_into_option.stderr
index 9396ea4c064..12de3b46088 100644
--- a/src/tools/clippy/tests/ui/result_map_or_into_option.stderr
+++ b/src/tools/clippy/tests/ui/result_map_or_into_option.stderr
@@ -7,5 +7,5 @@ LL |     let _ = opt.map_or(None, Some);
    = note: `-D clippy::result-map-or-into-option` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::result_map_or_into_option)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/seek_from_current.stderr b/src/tools/clippy/tests/ui/seek_from_current.stderr
index 42eb342c10a..4858cb82e7e 100644
--- a/src/tools/clippy/tests/ui/seek_from_current.stderr
+++ b/src/tools/clippy/tests/ui/seek_from_current.stderr
@@ -7,5 +7,5 @@ LL |     f.seek(SeekFrom::Current(0))?;
    = note: `-D clippy::seek-from-current` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::seek_from_current)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/self_named_constructors.stderr b/src/tools/clippy/tests/ui/self_named_constructors.stderr
index f299b860d47..8083ff96515 100644
--- a/src/tools/clippy/tests/ui/self_named_constructors.stderr
+++ b/src/tools/clippy/tests/ui/self_named_constructors.stderr
@@ -11,5 +11,5 @@ LL | |     }
    = note: `-D clippy::self-named-constructors` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::self_named_constructors)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/serde.stderr b/src/tools/clippy/tests/ui/serde.stderr
index e5d64e27164..079ba42bd2b 100644
--- a/src/tools/clippy/tests/ui/serde.stderr
+++ b/src/tools/clippy/tests/ui/serde.stderr
@@ -13,5 +13,5 @@ LL | |     }
    = note: `-D clippy::serde-api-misuse` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::serde_api_misuse)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/should_panic_without_expect.stderr b/src/tools/clippy/tests/ui/should_panic_without_expect.stderr
index dfcef52a9f5..b13db83bd5c 100644
--- a/src/tools/clippy/tests/ui/should_panic_without_expect.stderr
+++ b/src/tools/clippy/tests/ui/should_panic_without_expect.stderr
@@ -10,5 +10,5 @@ note: the lint level is defined here
 LL | #![deny(clippy::should_panic_without_expect)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr
index cf5688a9782..4738bef3ae9 100644
--- a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr
+++ b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.stderr
@@ -7,5 +7,5 @@ LL |     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
    = note: `-D clippy::string-from-utf8-as-bytes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::string_from_utf8_as_bytes)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/string_to_string.stderr b/src/tools/clippy/tests/ui/string_to_string.stderr
index 27a84431507..f1f8e176bc5 100644
--- a/src/tools/clippy/tests/ui/string_to_string.stderr
+++ b/src/tools/clippy/tests/ui/string_to_string.stderr
@@ -8,5 +8,5 @@ LL |     let mut v = message.to_string();
    = note: `-D clippy::string-to-string` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::string_to_string)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/tests_outside_test_module.stderr b/src/tools/clippy/tests/ui/tests_outside_test_module.stderr
index 112d6ce1f2c..ec0cdea83d6 100644
--- a/src/tools/clippy/tests/ui/tests_outside_test_module.stderr
+++ b/src/tools/clippy/tests/ui/tests_outside_test_module.stderr
@@ -8,5 +8,5 @@ LL | fn my_test() {}
    = note: `-D clippy::tests-outside-test-module` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::tests_outside_test_module)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/track-diagnostics.stderr b/src/tools/clippy/tests/ui/track-diagnostics.stderr
index 39418d35928..131adfd588c 100644
--- a/src/tools/clippy/tests/ui/track-diagnostics.stderr
+++ b/src/tools/clippy/tests/ui/track-diagnostics.stderr
@@ -5,6 +5,6 @@ LL | const S: A = B;
    |              ^ expected `A`, found `B`
 -Ztrack-diagnostics: created at compiler/rustc_infer/src/infer/error_reporting/mod.rs:LL:CC
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/src/tools/clippy/tests/ui/types.stderr b/src/tools/clippy/tests/ui/types.stderr
index b253cf33867..f7473e1c5c5 100644
--- a/src/tools/clippy/tests/ui/types.stderr
+++ b/src/tools/clippy/tests/ui/types.stderr
@@ -7,5 +7,5 @@ LL |     let c_i64: i64 = c as i64;
    = note: `-D clippy::cast-lossless` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cast_lossless)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.stderr b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.stderr
index 221efeb50cd..736a68ab1c7 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.stderr
+++ b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.stderr
@@ -12,5 +12,5 @@ LL -     println!("val='{}'", var);
 LL +     println!("val='{var}'");
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/unknown_attribute.stderr b/src/tools/clippy/tests/ui/unknown_attribute.stderr
index 618c5980d64..edad35d1591 100644
--- a/src/tools/clippy/tests/ui/unknown_attribute.stderr
+++ b/src/tools/clippy/tests/ui/unknown_attribute.stderr
@@ -4,5 +4,5 @@ error: usage of unknown attribute
 LL | #[clippy::unknown]
    |           ^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui/vec_resize_to_zero.stderr b/src/tools/clippy/tests/ui/vec_resize_to_zero.stderr
index 715c9923b2e..c16ba4e5262 100644
--- a/src/tools/clippy/tests/ui/vec_resize_to_zero.stderr
+++ b/src/tools/clippy/tests/ui/vec_resize_to_zero.stderr
@@ -10,5 +10,5 @@ LL |     v.resize(0, 5);
    = note: `-D clippy::vec-resize-to-zero` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::vec_resize_to_zero)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 

From 377da2f06bec5122c4caeaf6ad291420257baeea Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 17:10:10 +0000
Subject: [PATCH 69/71] Bless Miri tests

Co-authored-by: Adrian <adrian.iosdev@gmail.com>
---
 src/tools/miri/tests/extern-so/fail/function_not_in_so.stderr   | 2 +-
 .../concurrency/libc_pthread_create_main_terminate.stderr       | 2 +-
 .../concurrency/libc_pthread_create_too_few_args.stderr         | 2 +-
 .../concurrency/libc_pthread_create_too_many_args.stderr        | 2 +-
 .../fail-dep/concurrency/libc_pthread_join_detached.stderr      | 2 +-
 .../tests/fail-dep/concurrency/libc_pthread_join_joined.stderr  | 2 +-
 .../tests/fail-dep/concurrency/libc_pthread_join_main.stderr    | 2 +-
 .../fail-dep/concurrency/libc_pthread_join_multiple.stderr      | 2 +-
 .../tests/fail-dep/concurrency/libc_pthread_join_self.stderr    | 2 +-
 .../miri/tests/fail-dep/concurrency/unwind_top_of_stack.stderr  | 2 +-
 src/tools/miri/tests/fail-dep/shims/fs/close_stdout.stderr      | 2 +-
 src/tools/miri/tests/fail-dep/shims/fs/isolated_stdin.stderr    | 2 +-
 .../miri/tests/fail-dep/shims/fs/mkstemp_immutable_arg.stderr   | 2 +-
 src/tools/miri/tests/fail-dep/shims/fs/read_from_stdout.stderr  | 2 +-
 .../fail-dep/shims/fs/unix_open_missing_required_mode.stderr    | 2 +-
 src/tools/miri/tests/fail-dep/shims/fs/write_to_stdin.stderr    | 2 +-
 src/tools/miri/tests/fail-dep/shims/memchr_null.stderr          | 2 +-
 src/tools/miri/tests/fail-dep/shims/memcmp_null.stderr          | 2 +-
 src/tools/miri/tests/fail-dep/shims/memcmp_zero.stderr          | 2 +-
 src/tools/miri/tests/fail-dep/shims/memcpy_zero.stderr          | 2 +-
 src/tools/miri/tests/fail-dep/shims/memrchr_null.stderr         | 2 +-
 src/tools/miri/tests/fail-dep/shims/mmap_invalid_dealloc.stderr | 2 +-
 .../miri/tests/fail-dep/shims/mmap_use_after_munmap.stderr      | 2 +-
 src/tools/miri/tests/fail-dep/shims/munmap.stderr               | 2 +-
 src/tools/miri/tests/fail-dep/shims/munmap_partial.stderr       | 2 +-
 .../fail-dep/shims/sync/libc_pthread_cond_double_destroy.stderr | 2 +-
 .../shims/sync/libc_pthread_condattr_double_destroy.stderr      | 2 +-
 .../fail-dep/shims/sync/libc_pthread_mutex_NULL_deadlock.stderr | 2 +-
 .../fail-dep/shims/sync/libc_pthread_mutex_deadlock.stderr      | 2 +-
 .../shims/sync/libc_pthread_mutex_default_deadlock.stderr       | 2 +-
 .../shims/sync/libc_pthread_mutex_destroy_locked.stderr         | 2 +-
 .../shims/sync/libc_pthread_mutex_double_destroy.stderr         | 2 +-
 .../shims/sync/libc_pthread_mutex_normal_deadlock.stderr        | 2 +-
 .../shims/sync/libc_pthread_mutex_normal_unlock_unlocked.stderr | 2 +-
 .../fail-dep/shims/sync/libc_pthread_mutex_wrong_owner.stderr   | 2 +-
 .../shims/sync/libc_pthread_mutexattr_double_destroy.stderr     | 2 +-
 .../shims/sync/libc_pthread_rwlock_destroy_read_locked.stderr   | 2 +-
 .../shims/sync/libc_pthread_rwlock_destroy_write_locked.stderr  | 2 +-
 .../shims/sync/libc_pthread_rwlock_double_destroy.stderr        | 2 +-
 ...libc_pthread_rwlock_read_write_deadlock_single_thread.stderr | 2 +-
 .../shims/sync/libc_pthread_rwlock_read_wrong_owner.stderr      | 2 +-
 .../shims/sync/libc_pthread_rwlock_unlock_unlocked.stderr       | 2 +-
 .../shims/sync/libc_pthread_rwlock_write_read_deadlock.stderr   | 2 +-
 ...libc_pthread_rwlock_write_read_deadlock_single_thread.stderr | 2 +-
 .../shims/sync/libc_pthread_rwlock_write_write_deadlock.stderr  | 2 +-
 ...ibc_pthread_rwlock_write_write_deadlock_single_thread.stderr | 2 +-
 .../shims/sync/libc_pthread_rwlock_write_wrong_owner.stderr     | 2 +-
 src/tools/miri/tests/fail-dep/tokio/sleep.stderr                | 2 +-
 .../miri/tests/fail-dep/unsupported_incomplete_function.stderr  | 2 +-
 src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.stderr | 2 +-
 src/tools/miri/tests/fail/alloc/deallocate-bad-size.stderr      | 2 +-
 src/tools/miri/tests/fail/alloc/deallocate-twice.stderr         | 2 +-
 src/tools/miri/tests/fail/alloc/global_system_mixup.stderr      | 2 +-
 src/tools/miri/tests/fail/alloc/no_global_allocator.stderr      | 2 +-
 src/tools/miri/tests/fail/alloc/reallocate-bad-size.stderr      | 2 +-
 src/tools/miri/tests/fail/alloc/reallocate-change-alloc.stderr  | 2 +-
 src/tools/miri/tests/fail/alloc/reallocate-dangling.stderr      | 2 +-
 src/tools/miri/tests/fail/alloc/stack_free.stderr               | 2 +-
 .../tests/fail/both_borrows/alias_through_mutation.stack.stderr | 2 +-
 .../tests/fail/both_borrows/alias_through_mutation.tree.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut1.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut1.tree.stderr      | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut2.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut2.tree.stderr      | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut3.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut3.tree.stderr      | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut4.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/aliasing_mut4.tree.stderr      | 2 +-
 .../fail/both_borrows/box_exclusive_violation1.stack.stderr     | 2 +-
 .../fail/both_borrows/box_exclusive_violation1.tree.stderr      | 2 +-
 .../tests/fail/both_borrows/box_noalias_violation.stack.stderr  | 2 +-
 .../tests/fail/both_borrows/box_noalias_violation.tree.stderr   | 2 +-
 .../tests/fail/both_borrows/buggy_as_mut_slice.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/buggy_as_mut_slice.tree.stderr | 2 +-
 .../tests/fail/both_borrows/buggy_split_at_mut.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/buggy_split_at_mut.tree.stderr | 2 +-
 .../miri/tests/fail/both_borrows/illegal_write1.stack.stderr    | 2 +-
 .../miri/tests/fail/both_borrows/illegal_write1.tree.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/illegal_write5.stack.stderr    | 2 +-
 .../miri/tests/fail/both_borrows/illegal_write5.tree.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/illegal_write6.stack.stderr    | 2 +-
 .../miri/tests/fail/both_borrows/illegal_write6.tree.stderr     | 2 +-
 .../both_borrows/invalidate_against_protector2.stack.stderr     | 2 +-
 .../fail/both_borrows/invalidate_against_protector2.tree.stderr | 2 +-
 .../both_borrows/invalidate_against_protector3.stack.stderr     | 2 +-
 .../fail/both_borrows/invalidate_against_protector3.tree.stderr | 2 +-
 .../miri/tests/fail/both_borrows/issue-miri-1050-1.stack.stderr | 2 +-
 .../miri/tests/fail/both_borrows/issue-miri-1050-1.tree.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/issue-miri-1050-2.stack.stderr | 2 +-
 .../miri/tests/fail/both_borrows/issue-miri-1050-2.tree.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/load_invalid_shr.stack.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/load_invalid_shr.tree.stderr   | 2 +-
 .../fail/both_borrows/mut_exclusive_violation1.stack.stderr     | 2 +-
 .../fail/both_borrows/mut_exclusive_violation1.tree.stderr      | 2 +-
 .../fail/both_borrows/mut_exclusive_violation2.stack.stderr     | 2 +-
 .../fail/both_borrows/mut_exclusive_violation2.tree.stderr      | 2 +-
 .../tests/fail/both_borrows/newtype_pair_retagging.stack.stderr | 2 +-
 .../tests/fail/both_borrows/newtype_pair_retagging.tree.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/newtype_retagging.stack.stderr | 2 +-
 .../miri/tests/fail/both_borrows/newtype_retagging.tree.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/outdated_local.stack.stderr    | 2 +-
 .../miri/tests/fail/both_borrows/outdated_local.tree.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/pass_invalid_shr.stack.stderr  | 2 +-
 .../miri/tests/fail/both_borrows/pass_invalid_shr.tree.stderr   | 2 +-
 .../fail/both_borrows/pass_invalid_shr_option.stack.stderr      | 2 +-
 .../tests/fail/both_borrows/pass_invalid_shr_option.tree.stderr | 2 +-
 .../tests/fail/both_borrows/pass_invalid_shr_tuple.stack.stderr | 2 +-
 .../tests/fail/both_borrows/pass_invalid_shr_tuple.tree.stderr  | 2 +-
 .../tests/fail/both_borrows/retag_data_race_write.stack.stderr  | 2 +-
 .../tests/fail/both_borrows/retag_data_race_write.tree.stderr   | 2 +-
 .../tests/fail/both_borrows/return_invalid_shr.stack.stderr     | 2 +-
 .../miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr | 2 +-
 .../fail/both_borrows/return_invalid_shr_option.stack.stderr    | 2 +-
 .../fail/both_borrows/return_invalid_shr_option.tree.stderr     | 2 +-
 .../fail/both_borrows/return_invalid_shr_tuple.stack.stderr     | 2 +-
 .../fail/both_borrows/return_invalid_shr_tuple.tree.stderr      | 2 +-
 .../tests/fail/both_borrows/shr_frozen_violation1.stack.stderr  | 2 +-
 .../tests/fail/both_borrows/shr_frozen_violation1.tree.stderr   | 2 +-
 .../tests/fail/both_borrows/shr_frozen_violation2.stack.stderr  | 2 +-
 .../tests/fail/both_borrows/shr_frozen_violation2.tree.stderr   | 2 +-
 src/tools/miri/tests/fail/box-cell-alias.stderr                 | 2 +-
 src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr | 2 +-
 src/tools/miri/tests/fail/breakpoint.stderr                     | 2 +-
 .../miri/tests/fail/concurrency/read_only_atomic_cmpxchg.stderr | 2 +-
 .../tests/fail/concurrency/read_only_atomic_load_acquire.stderr | 2 +-
 src/tools/miri/tests/fail/const-ub-checks.stderr                | 2 +-
 src/tools/miri/tests/fail/coroutine-pinned-moved.stderr         | 2 +-
 .../tests/fail/dangling_pointers/dangling_pointer_deref.stderr  | 2 +-
 .../dangling_pointers/dangling_pointer_deref_match_never.stderr | 2 +-
 .../tests/fail/dangling_pointers/dangling_pointer_offset.stderr | 2 +-
 .../dangling_pointer_project_underscore_let.stderr              | 2 +-
 ...ngling_pointer_project_underscore_let_type_annotation.stderr | 2 +-
 .../dangling_pointer_project_underscore_match.stderr            | 2 +-
 .../miri/tests/fail/dangling_pointers/dangling_primitive.stderr | 2 +-
 .../miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr | 2 +-
 .../miri/tests/fail/dangling_pointers/deref-invalid-ptr.stderr  | 2 +-
 .../miri/tests/fail/dangling_pointers/deref_dangling_box.stderr | 2 +-
 .../miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr | 2 +-
 src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr     | 2 +-
 .../fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr  | 2 +-
 .../fail/dangling_pointers/maybe_null_pointer_write_zst.stderr  | 2 +-
 .../miri/tests/fail/dangling_pointers/null_pointer_deref.stderr | 2 +-
 .../tests/fail/dangling_pointers/null_pointer_deref_zst.stderr  | 2 +-
 .../miri/tests/fail/dangling_pointers/null_pointer_write.stderr | 2 +-
 .../tests/fail/dangling_pointers/null_pointer_write_zst.stderr  | 2 +-
 .../tests/fail/dangling_pointers/out_of_bounds_project.stderr   | 2 +-
 .../miri/tests/fail/dangling_pointers/out_of_bounds_read.stderr | 2 +-
 .../tests/fail/dangling_pointers/out_of_bounds_write.stderr     | 2 +-
 .../miri/tests/fail/dangling_pointers/stack_temporary.stderr    | 2 +-
 .../tests/fail/dangling_pointers/storage_dead_dangling.stderr   | 2 +-
 .../miri/tests/fail/dangling_pointers/wild_pointer_deref.stderr | 2 +-
 src/tools/miri/tests/fail/data_race/alloc_read_race.stderr      | 2 +-
 src/tools/miri/tests/fail/data_race/alloc_write_race.stderr     | 2 +-
 .../miri/tests/fail/data_race/atomic_read_na_write_race1.stderr | 2 +-
 .../miri/tests/fail/data_race/atomic_read_na_write_race2.stderr | 2 +-
 .../miri/tests/fail/data_race/atomic_write_na_read_race1.stderr | 2 +-
 .../miri/tests/fail/data_race/atomic_write_na_read_race2.stderr | 2 +-
 .../tests/fail/data_race/atomic_write_na_write_race1.stderr     | 2 +-
 .../tests/fail/data_race/atomic_write_na_write_race2.stderr     | 2 +-
 .../miri/tests/fail/data_race/dangling_thread_async_race.stderr | 2 +-
 src/tools/miri/tests/fail/data_race/dangling_thread_race.stderr | 2 +-
 src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr   | 2 +-
 src/tools/miri/tests/fail/data_race/dealloc_read_race2.stderr   | 2 +-
 .../miri/tests/fail/data_race/dealloc_read_race_stack.stderr    | 2 +-
 src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr  | 2 +-
 src/tools/miri/tests/fail/data_race/dealloc_write_race2.stderr  | 2 +-
 .../miri/tests/fail/data_race/dealloc_write_race_stack.stderr   | 2 +-
 .../miri/tests/fail/data_race/enable_after_join_to_main.stderr  | 2 +-
 src/tools/miri/tests/fail/data_race/fence_after_load.stderr     | 2 +-
 src/tools/miri/tests/fail/data_race/mixed_size_read.stderr      | 2 +-
 src/tools/miri/tests/fail/data_race/mixed_size_write.stderr     | 2 +-
 src/tools/miri/tests/fail/data_race/read_read_race1.stderr      | 2 +-
 src/tools/miri/tests/fail/data_race/read_read_race2.stderr      | 2 +-
 src/tools/miri/tests/fail/data_race/read_write_race.stderr      | 2 +-
 .../miri/tests/fail/data_race/read_write_race_stack.stderr      | 2 +-
 src/tools/miri/tests/fail/data_race/relax_acquire_race.stderr   | 2 +-
 src/tools/miri/tests/fail/data_race/release_seq_race.stderr     | 2 +-
 .../tests/fail/data_race/release_seq_race_same_thread.stderr    | 2 +-
 src/tools/miri/tests/fail/data_race/rmw_race.stderr             | 2 +-
 src/tools/miri/tests/fail/data_race/stack_pop_race.stderr       | 2 +-
 src/tools/miri/tests/fail/data_race/write_write_race.stderr     | 2 +-
 .../miri/tests/fail/data_race/write_write_race_stack.stderr     | 2 +-
 src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr        | 2 +-
 src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr      | 2 +-
 src/tools/miri/tests/fail/environ-gets-deallocated.stderr       | 2 +-
 src/tools/miri/tests/fail/erroneous_const.stderr                | 2 +-
 src/tools/miri/tests/fail/erroneous_const2.stderr               | 2 +-
 src/tools/miri/tests/fail/extern_static.stderr                  | 2 +-
 src/tools/miri/tests/fail/extern_static_in_const.stderr         | 2 +-
 src/tools/miri/tests/fail/extern_static_wrong_size.stderr       | 2 +-
 src/tools/miri/tests/fail/fast_math_both.stderr                 | 2 +-
 src/tools/miri/tests/fail/fast_math_first.stderr                | 2 +-
 src/tools/miri/tests/fail/fast_math_second.stderr               | 2 +-
 .../tests/fail/function_calls/arg_inplace_mutate.stack.stderr   | 2 +-
 .../tests/fail/function_calls/arg_inplace_mutate.tree.stderr    | 2 +-
 .../tests/fail/function_calls/arg_inplace_observe_after.stderr  | 2 +-
 .../fail/function_calls/arg_inplace_observe_during.none.stderr  | 2 +-
 .../fail/function_calls/arg_inplace_observe_during.stack.stderr | 2 +-
 .../fail/function_calls/arg_inplace_observe_during.tree.stderr  | 2 +-
 src/tools/miri/tests/fail/function_calls/check_arg_abi.stderr   | 2 +-
 .../miri/tests/fail/function_calls/check_arg_count_abort.stderr | 2 +-
 .../fail/function_calls/check_arg_count_too_few_args.stderr     | 2 +-
 .../fail/function_calls/check_arg_count_too_many_args.stderr    | 2 +-
 .../miri/tests/fail/function_calls/check_callback_abi.stderr    | 2 +-
 .../function_calls/exported_symbol_abi_mismatch.cache.stderr    | 2 +-
 .../function_calls/exported_symbol_abi_mismatch.fn_ptr.stderr   | 2 +-
 .../function_calls/exported_symbol_abi_mismatch.no_cache.stderr | 2 +-
 .../fail/function_calls/exported_symbol_bad_unwind1.stderr      | 2 +-
 .../fail/function_calls/exported_symbol_bad_unwind2.both.stderr | 2 +-
 .../exported_symbol_bad_unwind2.definition.stderr               | 2 +-
 .../exported_symbol_bad_unwind2.extern_block.stderr             | 2 +-
 .../tests/fail/function_calls/exported_symbol_clashing.stderr   | 2 +-
 .../fail/function_calls/exported_symbol_shim_clashing.stderr    | 2 +-
 .../fail/function_calls/exported_symbol_wrong_arguments.stderr  | 2 +-
 .../tests/fail/function_calls/exported_symbol_wrong_type.stderr | 2 +-
 .../fail/function_calls/return_pointer_aliasing.none.stderr     | 2 +-
 .../fail/function_calls/return_pointer_aliasing.stack.stderr    | 2 +-
 .../fail/function_calls/return_pointer_aliasing.tree.stderr     | 2 +-
 .../fail/function_calls/return_pointer_aliasing2.stack.stderr   | 2 +-
 .../fail/function_calls/return_pointer_aliasing2.tree.stderr    | 2 +-
 .../tests/fail/function_calls/return_pointer_on_unwind.stderr   | 2 +-
 .../fail/function_calls/simd_feature_flag_difference.stderr     | 2 +-
 src/tools/miri/tests/fail/function_calls/target_feature.stderr  | 2 +-
 .../fail/function_pointers/abi_mismatch_array_vs_struct.stderr  | 2 +-
 .../fail/function_pointers/abi_mismatch_int_vs_float.stderr     | 2 +-
 .../fail/function_pointers/abi_mismatch_raw_pointer.stderr      | 2 +-
 .../fail/function_pointers/abi_mismatch_return_type.stderr      | 2 +-
 .../tests/fail/function_pointers/abi_mismatch_simple.stderr     | 2 +-
 .../fail/function_pointers/abi_mismatch_too_few_args.stderr     | 2 +-
 .../fail/function_pointers/abi_mismatch_too_many_args.stderr    | 2 +-
 .../tests/fail/function_pointers/abi_mismatch_vector.stderr     | 2 +-
 .../tests/fail/function_pointers/cast_box_int_to_fn_ptr.stderr  | 2 +-
 .../miri/tests/fail/function_pointers/cast_int_to_fn_ptr.stderr | 2 +-
 src/tools/miri/tests/fail/function_pointers/deref_fn_ptr.stderr | 2 +-
 .../miri/tests/fail/function_pointers/execute_memory.stderr     | 2 +-
 .../miri/tests/fail/function_pointers/fn_ptr_offset.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/assume.stderr              | 2 +-
 src/tools/miri/tests/fail/intrinsics/copy_null.stderr           | 2 +-
 src/tools/miri/tests/fail/intrinsics/copy_overflow.stderr       | 2 +-
 src/tools/miri/tests/fail/intrinsics/copy_overlapping.stderr    | 2 +-
 src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/ctlz_nonzero.stderr        | 2 +-
 src/tools/miri/tests/fail/intrinsics/cttz_nonzero.stderr        | 2 +-
 src/tools/miri/tests/fail/intrinsics/div-by-zero.stderr         | 2 +-
 src/tools/miri/tests/fail/intrinsics/exact_div1.stderr          | 2 +-
 src/tools/miri/tests/fail/intrinsics/exact_div2.stderr          | 2 +-
 src/tools/miri/tests/fail/intrinsics/exact_div3.stderr          | 2 +-
 src/tools/miri/tests/fail/intrinsics/exact_div4.stderr          | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_32_inf1.stderr      | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_32_infneg1.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/float_to_int_32_nan.stderr | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_32_nanneg.stderr    | 2 +-
 src/tools/miri/tests/fail/intrinsics/float_to_int_32_neg.stderr | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_32_too_big1.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_32_too_big2.stderr  | 2 +-
 .../tests/fail/intrinsics/float_to_int_32_too_small1.stderr     | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_inf1.stderr      | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_infneg1.stderr   | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_infneg2.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/float_to_int_64_nan.stderr | 2 +-
 src/tools/miri/tests/fail/intrinsics/float_to_int_64_neg.stderr | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big1.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big2.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big3.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big4.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big5.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big6.stderr  | 2 +-
 .../miri/tests/fail/intrinsics/float_to_int_64_too_big7.stderr  | 2 +-
 .../tests/fail/intrinsics/float_to_int_64_too_small1.stderr     | 2 +-
 .../tests/fail/intrinsics/float_to_int_64_too_small2.stderr     | 2 +-
 .../tests/fail/intrinsics/float_to_int_64_too_small3.stderr     | 2 +-
 src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_1.stderr | 2 +-
 src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_2.stderr | 2 +-
 src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_3.stderr | 2 +-
 src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr | 2 +-
 src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr | 2 +-
 .../tests/fail/intrinsics/ptr_offset_from_unsigned_neg.stderr   | 2 +-
 .../miri/tests/fail/intrinsics/ptr_offset_int_plus_int.stderr   | 2 +-
 .../miri/tests/fail/intrinsics/ptr_offset_int_plus_ptr.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/ptr_offset_overflow.stderr | 2 +-
 .../miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr     | 2 +-
 src/tools/miri/tests/fail/intrinsics/raw_eq_on_ptr.stderr       | 2 +-
 src/tools/miri/tests/fail/intrinsics/rem-by-zero.stderr         | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-div-by-zero.stderr    | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-div-overflow.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-gather.stderr         | 2 +-
 .../miri/tests/fail/intrinsics/simd-reduce-invalid-bool.stderr  | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-rem-by-zero.stderr    | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-scatter.stderr        | 2 +-
 .../tests/fail/intrinsics/simd-select-bitmask-invalid.stderr    | 2 +-
 .../miri/tests/fail/intrinsics/simd-select-invalid-bool.stderr  | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr    | 2 +-
 src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr    | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_div1.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_shl.stderr       | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_shl2.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_shr.stderr       | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr      | 2 +-
 .../miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr    | 2 +-
 .../miri/tests/fail/intrinsics/write_bytes_overflow.stderr      | 2 +-
 src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr         | 2 +-
 src/tools/miri/tests/fail/invalid_bool.stderr                   | 2 +-
 src/tools/miri/tests/fail/invalid_char.stderr                   | 2 +-
 src/tools/miri/tests/fail/invalid_enum_tag.stderr               | 2 +-
 src/tools/miri/tests/fail/invalid_int.stderr                    | 2 +-
 src/tools/miri/tests/fail/issue-miri-1112.stderr                | 2 +-
 src/tools/miri/tests/fail/issue-miri-2432.stderr                | 2 +-
 src/tools/miri/tests/fail/memleak.stderr                        | 2 +-
 src/tools/miri/tests/fail/memleak_no_backtrace.stderr           | 2 +-
 src/tools/miri/tests/fail/memleak_rc.64bit.stderr               | 2 +-
 src/tools/miri/tests/fail/modifying_constants.stderr            | 2 +-
 src/tools/miri/tests/fail/never_match_never.stderr              | 2 +-
 src/tools/miri/tests/fail/never_say_never.stderr                | 2 +-
 src/tools/miri/tests/fail/never_transmute_humans.stderr         | 2 +-
 src/tools/miri/tests/fail/never_transmute_void.stderr           | 2 +-
 src/tools/miri/tests/fail/no_main.stderr                        | 2 +-
 src/tools/miri/tests/fail/overlapping_assignment.stderr         | 2 +-
 src/tools/miri/tests/fail/panic/bad_miri_start_panic.stderr     | 2 +-
 src/tools/miri/tests/fail/panic/bad_unwind.stderr               | 2 +-
 src/tools/miri/tests/fail/panic/double_panic.stderr             | 2 +-
 src/tools/miri/tests/fail/panic/no_std.stderr                   | 2 +-
 src/tools/miri/tests/fail/panic/panic_abort1.stderr             | 2 +-
 src/tools/miri/tests/fail/panic/panic_abort2.stderr             | 2 +-
 src/tools/miri/tests/fail/panic/panic_abort3.stderr             | 2 +-
 src/tools/miri/tests/fail/panic/panic_abort4.stderr             | 2 +-
 .../miri/tests/fail/panic/tls_macro_const_drop_panic.stderr     | 2 +-
 src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr     | 2 +-
 src/tools/miri/tests/fail/panic/unwind_panic_abort.stderr       | 2 +-
 .../miri/tests/fail/provenance/pointer_partial_overwrite.stderr | 2 +-
 .../miri/tests/fail/provenance/provenance_transmute.stderr      | 2 +-
 src/tools/miri/tests/fail/provenance/ptr_int_unexposed.stderr   | 2 +-
 src/tools/miri/tests/fail/provenance/ptr_invalid.stderr         | 2 +-
 src/tools/miri/tests/fail/provenance/ptr_invalid_offset.stderr  | 2 +-
 .../miri/tests/fail/provenance/strict_provenance_cast.stderr    | 2 +-
 src/tools/miri/tests/fail/rc_as_ptr.stderr                      | 2 +-
 src/tools/miri/tests/fail/reading_half_a_pointer.stderr         | 2 +-
 src/tools/miri/tests/fail/rustc-error.stderr                    | 2 +-
 .../miri/tests/fail/shims/backtrace/bad-backtrace-decl.stderr   | 2 +-
 .../miri/tests/fail/shims/backtrace/bad-backtrace-flags.stderr  | 2 +-
 .../miri/tests/fail/shims/backtrace/bad-backtrace-ptr.stderr    | 2 +-
 .../fail/shims/backtrace/bad-backtrace-resolve-flags.stderr     | 2 +-
 .../shims/backtrace/bad-backtrace-resolve-names-flags.stderr    | 2 +-
 .../tests/fail/shims/backtrace/bad-backtrace-size-flags.stderr  | 2 +-
 src/tools/miri/tests/fail/shims/fs/isolated_file.stderr         | 2 +-
 src/tools/miri/tests/fail/shims/shim_arg_size.stderr            | 2 +-
 src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.stderr    | 2 +-
 .../fail/stacked_borrows/deallocate_against_protector1.stderr   | 2 +-
 .../fail/stacked_borrows/disable_mut_does_not_merge_srw.stderr  | 2 +-
 .../tests/fail/stacked_borrows/drop_in_place_protector.stderr   | 2 +-
 .../miri/tests/fail/stacked_borrows/drop_in_place_retag.stderr  | 2 +-
 .../miri/tests/fail/stacked_borrows/exposed_only_ro.stderr      | 2 +-
 .../miri/tests/fail/stacked_borrows/fnentry_invalidation.stderr | 2 +-
 .../tests/fail/stacked_borrows/fnentry_invalidation2.stderr     | 2 +-
 .../miri/tests/fail/stacked_borrows/illegal_dealloc1.stderr     | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read1.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read2.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read3.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read4.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read5.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read6.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read7.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_read8.stderr  | 2 +-
 .../fail/stacked_borrows/illegal_read_despite_exposed1.stderr   | 2 +-
 .../fail/stacked_borrows/illegal_read_despite_exposed2.stderr   | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_write2.stderr | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_write3.stderr | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/illegal_write4.stderr | 2 +-
 .../fail/stacked_borrows/illegal_write_despite_exposed1.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/interior_mut1.stderr  | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/interior_mut2.stderr  | 2 +-
 .../fail/stacked_borrows/invalidate_against_protector1.stderr   | 2 +-
 .../miri/tests/fail/stacked_borrows/load_invalid_mut.stderr     | 2 +-
 .../miri/tests/fail/stacked_borrows/pass_invalid_mut.stderr     | 2 +-
 .../miri/tests/fail/stacked_borrows/pointer_smuggling.stderr    | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/raw_tracking.stderr   | 2 +-
 .../fail/stacked_borrows/retag_data_race_protected_read.stderr  | 2 +-
 .../miri/tests/fail/stacked_borrows/retag_data_race_read.stderr | 2 +-
 .../miri/tests/fail/stacked_borrows/return_invalid_mut.stderr   | 2 +-
 .../tests/fail/stacked_borrows/return_invalid_mut_option.stderr | 2 +-
 .../tests/fail/stacked_borrows/return_invalid_mut_tuple.stderr  | 2 +-
 .../fail/stacked_borrows/shared_rw_borrows_are_weak1.stderr     | 2 +-
 .../fail/stacked_borrows/shared_rw_borrows_are_weak2.stderr     | 2 +-
 .../fail/stacked_borrows/static_memory_modification.stderr      | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/track_caller.stderr   | 2 +-
 .../tests/fail/stacked_borrows/transmute-is-no-escape.stderr    | 2 +-
 .../miri/tests/fail/stacked_borrows/unescaped_local.stderr      | 2 +-
 .../miri/tests/fail/stacked_borrows/unescaped_static.stderr     | 2 +-
 src/tools/miri/tests/fail/stacked_borrows/zst_slice.stderr      | 2 +-
 src/tools/miri/tests/fail/static_memory_modification1.stderr    | 2 +-
 src/tools/miri/tests/fail/static_memory_modification2.stderr    | 2 +-
 src/tools/miri/tests/fail/static_memory_modification3.stderr    | 2 +-
 src/tools/miri/tests/fail/terminate-terminator.stderr           | 2 +-
 src/tools/miri/tests/fail/tls/tls_static_dealloc.stderr         | 2 +-
 src/tools/miri/tests/fail/tls_macro_leak.stderr                 | 2 +-
 src/tools/miri/tests/fail/tls_static_leak.stderr                | 2 +-
 src/tools/miri/tests/fail/transmute-pair-uninit.stderr          | 2 +-
 .../miri/tests/fail/tree_borrows/alternate-read-write.stderr    | 2 +-
 .../tests/fail/tree_borrows/children-can-alias.default.stderr   | 2 +-
 .../miri/tests/fail/tree_borrows/children-can-alias.uniq.stderr | 2 +-
 src/tools/miri/tests/fail/tree_borrows/error-range.stderr       | 2 +-
 .../miri/tests/fail/tree_borrows/fnentry_invalidation.stderr    | 2 +-
 src/tools/miri/tests/fail/tree_borrows/outside-range.stderr     | 2 +-
 .../tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr  | 2 +-
 src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr  | 2 +-
 .../fail/tree_borrows/reserved/cell-protected-write.stderr      | 2 +-
 .../tests/fail/tree_borrows/reserved/int-protected-write.stderr | 2 +-
 .../miri/tests/fail/tree_borrows/return_invalid_mut.stderr      | 2 +-
 src/tools/miri/tests/fail/tree_borrows/spurious_read.stderr     | 2 +-
 .../miri/tests/fail/tree_borrows/strongly-protected.stderr      | 2 +-
 src/tools/miri/tests/fail/tree_borrows/unique.default.stderr    | 2 +-
 src/tools/miri/tests/fail/tree_borrows/unique.uniq.stderr       | 2 +-
 .../miri/tests/fail/tree_borrows/write-during-2phase.stderr     | 2 +-
 src/tools/miri/tests/fail/type-too-large.stderr                 | 2 +-
 src/tools/miri/tests/fail/unaligned_pointers/alignment.stderr   | 2 +-
 .../miri/tests/fail/unaligned_pointers/atomic_unaligned.stderr  | 2 +-
 .../miri/tests/fail/unaligned_pointers/drop_in_place.stderr     | 2 +-
 .../miri/tests/fail/unaligned_pointers/dyn_alignment.stderr     | 2 +-
 .../field_requires_parent_struct_alignment.stderr               | 2 +-
 .../field_requires_parent_struct_alignment2.stderr              | 2 +-
 .../fail/unaligned_pointers/intptrcast_alignment_check.stderr   | 2 +-
 .../tests/fail/unaligned_pointers/reference_to_packed.stderr    | 2 +-
 .../miri/tests/fail/unaligned_pointers/unaligned_ptr1.stderr    | 2 +-
 .../miri/tests/fail/unaligned_pointers/unaligned_ptr2.stderr    | 2 +-
 .../miri/tests/fail/unaligned_pointers/unaligned_ptr3.stderr    | 2 +-
 .../miri/tests/fail/unaligned_pointers/unaligned_ptr4.stderr    | 2 +-
 .../miri/tests/fail/unaligned_pointers/unaligned_ptr_zst.stderr | 2 +-
 .../tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr  | 2 +-
 src/tools/miri/tests/fail/uninit_buffer.stderr                  | 2 +-
 src/tools/miri/tests/fail/uninit_buffer_with_provenance.stderr  | 2 +-
 src/tools/miri/tests/fail/uninit_byte_read.stderr               | 2 +-
 src/tools/miri/tests/fail/unreachable.stderr                    | 2 +-
 src/tools/miri/tests/fail/unsized-local.stderr                  | 2 +-
 src/tools/miri/tests/fail/unsupported_foreign_function.stderr   | 2 +-
 src/tools/miri/tests/fail/unwind-action-terminate.stderr        | 2 +-
 .../tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr   | 2 +-
 .../tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr   | 2 +-
 .../tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr   | 2 +-
 .../tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr   | 2 +-
 src/tools/miri/tests/fail/validity/dangling_ref1.stderr         | 2 +-
 src/tools/miri/tests/fail/validity/dangling_ref2.stderr         | 2 +-
 src/tools/miri/tests/fail/validity/dangling_ref3.stderr         | 2 +-
 src/tools/miri/tests/fail/validity/invalid_bool.stderr          | 2 +-
 src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr   | 2 +-
 src/tools/miri/tests/fail/validity/invalid_char.stderr          | 2 +-
 src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr   | 2 +-
 src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr      | 2 +-
 src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr    | 2 +-
 src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr  | 2 +-
 src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr      | 2 +-
 .../tests/fail/validity/match_binder_checks_validity1.stderr    | 2 +-
 .../tests/fail/validity/match_binder_checks_validity2.stderr    | 2 +-
 src/tools/miri/tests/fail/validity/nonzero.stderr               | 2 +-
 src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr   | 2 +-
 src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr   | 2 +-
 src/tools/miri/tests/fail/validity/too-big-slice.stderr         | 2 +-
 src/tools/miri/tests/fail/validity/too-big-unsized.stderr       | 2 +-
 src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr | 2 +-
 src/tools/miri/tests/fail/validity/uninit_float.stderr          | 2 +-
 src/tools/miri/tests/fail/validity/uninit_integer.stderr        | 2 +-
 src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr        | 2 +-
 src/tools/miri/tests/fail/weak_memory/racing_mixed_size.stderr  | 2 +-
 .../miri/tests/fail/weak_memory/racing_mixed_size_read.stderr   | 2 +-
 src/tools/miri/tests/fail/zst1.stderr                           | 2 +-
 src/tools/miri/tests/fail/zst2.stderr                           | 2 +-
 src/tools/miri/tests/fail/zst3.stderr                           | 2 +-
 472 files changed, 472 insertions(+), 472 deletions(-)

diff --git a/src/tools/miri/tests/extern-so/fail/function_not_in_so.stderr b/src/tools/miri/tests/extern-so/fail/function_not_in_so.stderr
index e9bc3220471..c031cb0146a 100644
--- a/src/tools/miri/tests/extern-so/fail/function_not_in_so.stderr
+++ b/src/tools/miri/tests/extern-so/fail/function_not_in_so.stderr
@@ -10,5 +10,5 @@ LL |         foo();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_main_terminate.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_main_terminate.stderr
index c5093c0e601..078b7d2e0d8 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_main_terminate.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_main_terminate.stderr
@@ -2,5 +2,5 @@ error: the main thread terminated without waiting for all remaining threads
 
 note: pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr
index c2de4afd68f..383b93024bb 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_few_args.stderr
@@ -10,5 +10,5 @@ LL |     panic!()
    = note: inside `thread_start` at RUSTLIB/core/src/panic.rs:LL:CC
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr
index 85ae930d439..70a565ee7c7 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_create_too_many_args.stderr
@@ -10,5 +10,5 @@ LL |     panic!()
    = note: inside `thread_start` at RUSTLIB/core/src/panic.rs:LL:CC
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_detached.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_detached.stderr
index 763e0d3665d..7238dfb40b7 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_detached.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_detached.stderr
@@ -11,5 +11,5 @@ LL |         assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr
index a3253e2ef93..e501a086cca 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr
@@ -11,5 +11,5 @@ LL |         assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr
index 09e14d46a96..b2edabd7cc9 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr
@@ -11,5 +11,5 @@ LL |             assert_eq!(libc::pthread_join(thread_id, ptr::null_mut()), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_multiple.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_multiple.stderr
index db5d7bfd5da..605d6cdf0a4 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_multiple.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_multiple.stderr
@@ -11,5 +11,5 @@ LL | ...   assert_eq!(libc::pthread_join(native_copy, ptr::null_mut()), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_self.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_self.stderr
index 8db4a83f9ce..9ec749acddd 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_self.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_self.stderr
@@ -11,5 +11,5 @@ LL |             assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/unwind_top_of_stack.stderr b/src/tools/miri/tests/fail-dep/concurrency/unwind_top_of_stack.stderr
index fccd3fbbc9d..2339bab3e9f 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/unwind_top_of_stack.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/unwind_top_of_stack.stderr
@@ -17,5 +17,5 @@ LL | | }
    = note: BACKTRACE:
    = note: inside `thread_start` at $DIR/unwind_top_of_stack.rs:LL:CC
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/fs/close_stdout.stderr b/src/tools/miri/tests/fail-dep/shims/fs/close_stdout.stderr
index 02f1eee97fc..7547ec41719 100644
--- a/src/tools/miri/tests/fail-dep/shims/fs/close_stdout.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/fs/close_stdout.stderr
@@ -10,5 +10,5 @@ LL |         libc::close(1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/fs/isolated_stdin.stderr b/src/tools/miri/tests/fail-dep/shims/fs/isolated_stdin.stderr
index ed826147e3b..1d6626dda70 100644
--- a/src/tools/miri/tests/fail-dep/shims/fs/isolated_stdin.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/fs/isolated_stdin.stderr
@@ -11,5 +11,5 @@ LL |         libc::read(0, bytes.as_mut_ptr() as *mut libc::c_void, 512);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/fs/mkstemp_immutable_arg.stderr b/src/tools/miri/tests/fail-dep/shims/fs/mkstemp_immutable_arg.stderr
index 35ff1926b06..7a2757557ef 100644
--- a/src/tools/miri/tests/fail-dep/shims/fs/mkstemp_immutable_arg.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/fs/mkstemp_immutable_arg.stderr
@@ -16,5 +16,5 @@ LL |     test_mkstemp_immutable_arg();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/fs/read_from_stdout.stderr b/src/tools/miri/tests/fail-dep/shims/fs/read_from_stdout.stderr
index bcece7ad4e5..355e16d5c34 100644
--- a/src/tools/miri/tests/fail-dep/shims/fs/read_from_stdout.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/fs/read_from_stdout.stderr
@@ -10,5 +10,5 @@ LL |         libc::read(1, bytes.as_mut_ptr() as *mut libc::c_void, 512);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/fs/unix_open_missing_required_mode.stderr b/src/tools/miri/tests/fail-dep/shims/fs/unix_open_missing_required_mode.stderr
index 5a8e7352c76..0988eefe222 100644
--- a/src/tools/miri/tests/fail-dep/shims/fs/unix_open_missing_required_mode.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/fs/unix_open_missing_required_mode.stderr
@@ -16,5 +16,5 @@ LL |     test_file_open_missing_needed_mode();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/fs/write_to_stdin.stderr b/src/tools/miri/tests/fail-dep/shims/fs/write_to_stdin.stderr
index d4a38e1ca96..e2ebe234b0b 100644
--- a/src/tools/miri/tests/fail-dep/shims/fs/write_to_stdin.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/fs/write_to_stdin.stderr
@@ -10,5 +10,5 @@ LL |         libc::write(0, bytes.as_ptr() as *const libc::c_void, 5);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/memchr_null.stderr b/src/tools/miri/tests/fail-dep/shims/memchr_null.stderr
index 54b58f22c6c..b76722f5f8f 100644
--- a/src/tools/miri/tests/fail-dep/shims/memchr_null.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/memchr_null.stderr
@@ -11,5 +11,5 @@ LL |         libc::memchr(ptr::null(), 0, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/memcmp_null.stderr b/src/tools/miri/tests/fail-dep/shims/memcmp_null.stderr
index 8b2882fc243..5c6ba4fd979 100644
--- a/src/tools/miri/tests/fail-dep/shims/memcmp_null.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/memcmp_null.stderr
@@ -11,5 +11,5 @@ LL |         libc::memcmp(ptr::null(), ptr::null(), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/memcmp_zero.stderr b/src/tools/miri/tests/fail-dep/shims/memcmp_zero.stderr
index e21b9b06008..4ab37ab569f 100644
--- a/src/tools/miri/tests/fail-dep/shims/memcmp_zero.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/memcmp_zero.stderr
@@ -11,5 +11,5 @@ LL |         libc::memcmp(ptr.cast(), ptr.cast(), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/memcpy_zero.stderr b/src/tools/miri/tests/fail-dep/shims/memcpy_zero.stderr
index 7c1c3fe20c4..3e1ee7b86e3 100644
--- a/src/tools/miri/tests/fail-dep/shims/memcpy_zero.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/memcpy_zero.stderr
@@ -11,5 +11,5 @@ LL |         libc::memcpy(to.cast(), from.cast(), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/memrchr_null.stderr b/src/tools/miri/tests/fail-dep/shims/memrchr_null.stderr
index cc11ba89f8f..0cc7ac19feb 100644
--- a/src/tools/miri/tests/fail-dep/shims/memrchr_null.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/memrchr_null.stderr
@@ -11,5 +11,5 @@ LL |         libc::memrchr(ptr::null(), 0, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/mmap_invalid_dealloc.stderr b/src/tools/miri/tests/fail-dep/shims/mmap_invalid_dealloc.stderr
index 54e0cd5275d..cec67b6ef84 100644
--- a/src/tools/miri/tests/fail-dep/shims/mmap_invalid_dealloc.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/mmap_invalid_dealloc.stderr
@@ -11,5 +11,5 @@ LL |         libc::free(ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/mmap_use_after_munmap.stderr b/src/tools/miri/tests/fail-dep/shims/mmap_use_after_munmap.stderr
index 35d26972839..21b4baa5009 100644
--- a/src/tools/miri/tests/fail-dep/shims/mmap_use_after_munmap.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/mmap_use_after_munmap.stderr
@@ -43,5 +43,5 @@ LL |         libc::munmap(ptr, 4096);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/src/tools/miri/tests/fail-dep/shims/munmap.stderr b/src/tools/miri/tests/fail-dep/shims/munmap.stderr
index cb47769c063..f17473677f6 100644
--- a/src/tools/miri/tests/fail-dep/shims/munmap.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/munmap.stderr
@@ -35,5 +35,5 @@ LL | |         )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/src/tools/miri/tests/fail-dep/shims/munmap_partial.stderr b/src/tools/miri/tests/fail-dep/shims/munmap_partial.stderr
index 9a084c50437..14eb9d32053 100644
--- a/src/tools/miri/tests/fail-dep/shims/munmap_partial.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/munmap_partial.stderr
@@ -25,5 +25,5 @@ LL |         libc::munmap(ptr, 1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_cond_double_destroy.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_cond_double_destroy.stderr
index ecfedf75370..899c217efbf 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_cond_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_cond_double_destroy.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_cond_destroy(cond.as_mut_ptr());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_condattr_double_destroy.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_condattr_double_destroy.stderr
index f39d909adbd..ef75b03162d 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_condattr_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_condattr_double_destroy.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_condattr_destroy(attr.as_mut_ptr());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_NULL_deadlock.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_NULL_deadlock.stderr
index 4a138e6f8a2..3675ce49f30 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_NULL_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_NULL_deadlock.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_mutex_lock(&mut mutex as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_deadlock.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_deadlock.stderr
index 599655a8692..272bee38b5a 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_deadlock.stderr
@@ -8,5 +8,5 @@ LL |             assert_eq!(libc::pthread_mutex_lock(lock_copy.0.get() as *mut _
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_default_deadlock.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_default_deadlock.stderr
index 8aea3f5c693..4d41141b545 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_default_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_default_deadlock.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_mutex_lock(&mut mutex as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_destroy_locked.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_destroy_locked.stderr
index a8ab948116e..ed5e27b607a 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_destroy_locked.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_destroy_locked.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_mutex_destroy(&mut mutex as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_double_destroy.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_double_destroy.stderr
index 9620fdbd18b..05b35ee3b30 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_double_destroy.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_deadlock.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_deadlock.stderr
index b7877d3aa39..16de503bebf 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_deadlock.stderr
@@ -8,5 +8,5 @@ LL |         libc::pthread_mutex_lock(&mut mutex as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_unlock_unlocked.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_unlock_unlocked.stderr
index 754137b85b9..d717b4ec56b 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_unlock_unlocked.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_normal_unlock_unlocked.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_mutex_unlock(&mut mutex as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_wrong_owner.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_wrong_owner.stderr
index aa81b06fc80..a1de36db966 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_wrong_owner.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutex_wrong_owner.stderr
@@ -11,5 +11,5 @@ LL | ...t_eq!(libc::pthread_mutex_unlock(lock_copy.0.get() as *mut _), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutexattr_double_destroy.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutexattr_double_destroy.stderr
index 82949047d2a..a8425e6f81d 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutexattr_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_mutexattr_double_destroy.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_read_locked.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_read_locked.stderr
index be73e7f1e2a..bb90545c503 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_read_locked.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_read_locked.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_rwlock_destroy(rw.get());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_write_locked.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_write_locked.stderr
index bc2713a5ffb..7210c6a742a 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_write_locked.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_destroy_write_locked.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_rwlock_destroy(rw.get());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_double_destroy.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_double_destroy.stderr
index 5004f84358d..5032e98f116 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_double_destroy.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_rwlock_destroy(&mut lock);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_write_deadlock_single_thread.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_write_deadlock_single_thread.stderr
index 075c8f0ef52..21383825f81 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_write_deadlock_single_thread.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_write_deadlock_single_thread.stderr
@@ -8,5 +8,5 @@ LL |         libc::pthread_rwlock_wrlock(rw.get());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_wrong_owner.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_wrong_owner.stderr
index 7dfa27b43d0..d1b7d5ca1ad 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_wrong_owner.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_read_wrong_owner.stderr
@@ -11,5 +11,5 @@ LL | ...   assert_eq!(libc::pthread_rwlock_unlock(lock_copy.0.get() as *mut _),
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_unlock_unlocked.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_unlock_unlocked.stderr
index 1c25ac2c048..98b09472904 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_unlock_unlocked.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_unlock_unlocked.stderr
@@ -11,5 +11,5 @@ LL |         libc::pthread_rwlock_unlock(rw.get());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock.stderr
index 333fb1afb91..6271d5cb2ff 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock.stderr
@@ -8,5 +8,5 @@ LL |             assert_eq!(libc::pthread_rwlock_wrlock(lock_copy.0.get() as *mu
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock_single_thread.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock_single_thread.stderr
index caab19a782f..3d09c6dbce7 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock_single_thread.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_read_deadlock_single_thread.stderr
@@ -8,5 +8,5 @@ LL |         libc::pthread_rwlock_rdlock(rw.get());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock.stderr
index 93bede54fcf..faaf3f5e9a0 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock.stderr
@@ -8,5 +8,5 @@ LL |             assert_eq!(libc::pthread_rwlock_wrlock(lock_copy.0.get() as *mu
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock_single_thread.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock_single_thread.stderr
index 30f5f447c71..3dc99a1fd19 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock_single_thread.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_write_deadlock_single_thread.stderr
@@ -8,5 +8,5 @@ LL |         libc::pthread_rwlock_wrlock(rw.get());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_wrong_owner.stderr b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_wrong_owner.stderr
index 5bf402c775a..dea2529b865 100644
--- a/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_wrong_owner.stderr
+++ b/src/tools/miri/tests/fail-dep/shims/sync/libc_pthread_rwlock_write_wrong_owner.stderr
@@ -11,5 +11,5 @@ LL | ...   assert_eq!(libc::pthread_rwlock_unlock(lock_copy.0.get() as *mut _),
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/tokio/sleep.stderr b/src/tools/miri/tests/fail-dep/tokio/sleep.stderr
index ac2a984ed51..59179478c30 100644
--- a/src/tools/miri/tests/fail-dep/tokio/sleep.stderr
+++ b/src/tools/miri/tests/fail-dep/tokio/sleep.stderr
@@ -11,5 +11,5 @@ LL | |         ))
    |
    = help: this is likely not a bug in the program; it indicates that the program performed an operation that the interpreter does not support
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail-dep/unsupported_incomplete_function.stderr b/src/tools/miri/tests/fail-dep/unsupported_incomplete_function.stderr
index ec2bba61172..fabe3bbf121 100644
--- a/src/tools/miri/tests/fail-dep/unsupported_incomplete_function.stderr
+++ b/src/tools/miri/tests/fail-dep/unsupported_incomplete_function.stderr
@@ -10,5 +10,5 @@ LL |         libc::signal(libc::SIGPIPE, libc::SIG_IGN);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.stderr b/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.stderr
index 095eeeb79de..40ed093198d 100644
--- a/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.stderr
+++ b/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.stderr
@@ -16,5 +16,5 @@ LL |         dealloc(x, Layout::from_size_align_unchecked(1, 2));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/deallocate-bad-size.stderr b/src/tools/miri/tests/fail/alloc/deallocate-bad-size.stderr
index 5fe93c841b2..e9b935d2c83 100644
--- a/src/tools/miri/tests/fail/alloc/deallocate-bad-size.stderr
+++ b/src/tools/miri/tests/fail/alloc/deallocate-bad-size.stderr
@@ -16,5 +16,5 @@ LL |         dealloc(x, Layout::from_size_align_unchecked(2, 1));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/deallocate-twice.stderr b/src/tools/miri/tests/fail/alloc/deallocate-twice.stderr
index 48d63e59051..76abd96e24a 100644
--- a/src/tools/miri/tests/fail/alloc/deallocate-twice.stderr
+++ b/src/tools/miri/tests/fail/alloc/deallocate-twice.stderr
@@ -26,5 +26,5 @@ LL |         dealloc(x, Layout::from_size_align_unchecked(1, 1));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr b/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
index 62ffb8142a3..de76e925c11 100644
--- a/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
+++ b/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
@@ -17,5 +17,5 @@ LL |         System.deallocate(ptr, l);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/no_global_allocator.stderr b/src/tools/miri/tests/fail/alloc/no_global_allocator.stderr
index fe6a22fadc9..bd2a6c628f9 100644
--- a/src/tools/miri/tests/fail/alloc/no_global_allocator.stderr
+++ b/src/tools/miri/tests/fail/alloc/no_global_allocator.stderr
@@ -8,5 +8,5 @@ LL |         __rust_alloc(1, 1);
    = note: BACKTRACE:
    = note: inside `start` at $DIR/no_global_allocator.rs:LL:CC
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/reallocate-bad-size.stderr b/src/tools/miri/tests/fail/alloc/reallocate-bad-size.stderr
index 24cabb39564..5347e7a95ac 100644
--- a/src/tools/miri/tests/fail/alloc/reallocate-bad-size.stderr
+++ b/src/tools/miri/tests/fail/alloc/reallocate-bad-size.stderr
@@ -16,5 +16,5 @@ LL |         let _y = realloc(x, Layout::from_size_align_unchecked(2, 1), 1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.stderr b/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.stderr
index d4e907bd067..fb3b035b116 100644
--- a/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.stderr
+++ b/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.stderr
@@ -21,5 +21,5 @@ LL |         let _y = realloc(x, Layout::from_size_align_unchecked(1, 1), 1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/reallocate-dangling.stderr b/src/tools/miri/tests/fail/alloc/reallocate-dangling.stderr
index 52cc579c1e6..9b8a8926201 100644
--- a/src/tools/miri/tests/fail/alloc/reallocate-dangling.stderr
+++ b/src/tools/miri/tests/fail/alloc/reallocate-dangling.stderr
@@ -26,5 +26,5 @@ LL |         let _z = realloc(x, Layout::from_size_align_unchecked(1, 1), 1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/alloc/stack_free.stderr b/src/tools/miri/tests/fail/alloc/stack_free.stderr
index 7c14d372f0c..2adec68c0dd 100644
--- a/src/tools/miri/tests/fail/alloc/stack_free.stderr
+++ b/src/tools/miri/tests/fail/alloc/stack_free.stderr
@@ -20,5 +20,5 @@ LL |     drop(bad_box);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.stack.stderr b/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.stack.stderr
index b22db3eb121..6903a52f304 100644
--- a/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.stack.stderr
@@ -24,5 +24,5 @@ LL |     *target = 13;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.tree.stderr b/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.tree.stderr
index 655f1b57777..db36d696e1d 100644
--- a/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/alias_through_mutation.tree.stderr
@@ -28,5 +28,5 @@ LL |     *target = 13;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.stack.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.stack.stderr
index 678211a700d..fe1f7060f1e 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.stack.stderr
@@ -26,5 +26,5 @@ LL |     safe_raw(xraw, xraw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.tree.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.tree.stderr
index 3271a04eae7..4ee154eeb99 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut1.tree.stderr
@@ -27,5 +27,5 @@ LL |     safe_raw(xraw, xraw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.stack.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.stack.stderr
index 90134ce367a..c5bdfcb8fe4 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.stack.stderr
@@ -26,5 +26,5 @@ LL |     safe_raw(xshr, xraw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.tree.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.tree.stderr
index f2694b51ca4..4b15e931654 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut2.tree.stderr
@@ -27,5 +27,5 @@ LL |     safe_raw(xshr, xraw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.stack.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.stack.stderr
index a457bd9a6ac..b04139f3bd9 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.stack.stderr
@@ -29,5 +29,5 @@ LL |     safe_raw(xraw, xshr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.tree.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.tree.stderr
index 595381c16ad..7b8082292a1 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut3.tree.stderr
@@ -27,5 +27,5 @@ LL |     safe_raw(xraw, xshr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.stack.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.stack.stderr
index b53ae9bd550..383eb086d1e 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.stack.stderr
@@ -26,5 +26,5 @@ LL |     safe_raw(xshr, xraw as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.tree.stderr b/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.tree.stderr
index 106e5c19bf2..5dbcd393218 100644
--- a/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/aliasing_mut4.tree.stderr
@@ -35,5 +35,5 @@ LL |     safe_raw(xshr, xraw as *mut _);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.stack.stderr b/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.stack.stderr
index 76f4e81f71b..bed0b880c3a 100644
--- a/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.stack.stderr
@@ -34,5 +34,5 @@ LL |     demo_box_advanced_unique(Box::new(0));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.tree.stderr b/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.tree.stderr
index 97f82db6fe7..68ed09409bf 100644
--- a/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/box_exclusive_violation1.tree.stderr
@@ -38,5 +38,5 @@ LL |     demo_box_advanced_unique(Box::new(0));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.stack.stderr b/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.stack.stderr
index 59377aeb971..6e87d3ce06b 100644
--- a/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.stack.stderr
@@ -26,5 +26,5 @@ LL |         test(Box::from_raw(ptr), ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr b/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr
index 1ecd6620806..824a2d36fc4 100644
--- a/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr
@@ -34,5 +34,5 @@ LL |         test(Box::from_raw(ptr), ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.stack.stderr b/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.stack.stderr
index fa3d7ca3676..d2bf4c6a59c 100644
--- a/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.stack.stderr
@@ -24,5 +24,5 @@ LL |         unsafe { from_raw_parts_mut(self_.as_ptr() as *mut T, self_.len())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.tree.stderr b/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.tree.stderr
index 9519c83f71c..4e5a8bbe0e0 100644
--- a/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/buggy_as_mut_slice.tree.stderr
@@ -28,5 +28,5 @@ LL |     v1[1] = 5;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.stack.stderr b/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.stack.stderr
index daa4339225d..71d962a5523 100644
--- a/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.stack.stderr
@@ -33,5 +33,5 @@ LL |     let (a, b) = safe::split_at_mut(&mut array, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.tree.stderr b/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.tree.stderr
index 4fd92df75d6..7fc795db097 100644
--- a/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/buggy_split_at_mut.tree.stderr
@@ -28,5 +28,5 @@ LL |     a[1] = 5;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write1.stack.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write1.stack.stderr
index c1e49181465..3a9faeb80ee 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write1.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write1.stack.stderr
@@ -19,5 +19,5 @@ LL |         let x: *mut u32 = xref as *const _ as *mut _;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write1.tree.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write1.tree.stderr
index bb72159be65..5dd51b5f257 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write1.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write1.tree.stderr
@@ -16,5 +16,5 @@ LL |     let xref = &*target;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write5.stack.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write5.stack.stderr
index c71780b7e03..16f8a3cbd02 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write5.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write5.stack.stderr
@@ -24,5 +24,5 @@ LL |     unsafe { *xraw = 15 };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write5.tree.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write5.tree.stderr
index 05cc69553a0..3698937d6fc 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write5.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write5.tree.stderr
@@ -28,5 +28,5 @@ LL |     unsafe { *xraw = 15 };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write6.stack.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write6.stack.stderr
index 3d3d2a24c28..159b6cc9a8e 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write6.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write6.stack.stderr
@@ -26,5 +26,5 @@ LL |     foo(x, p);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr
index 64e08f545e3..37d5147b5d0 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr
@@ -34,5 +34,5 @@ LL |     foo(x, p);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.stack.stderr b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.stack.stderr
index 8f677bd547c..5d093aeae88 100644
--- a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.stack.stderr
@@ -26,5 +26,5 @@ LL |     inner(xraw, xref);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.tree.stderr b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.tree.stderr
index 66f7f1788e4..4ba80e13318 100644
--- a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector2.tree.stderr
@@ -28,5 +28,5 @@ LL |     inner(xraw, xref);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr
index 1648ca9e58b..f6eeef33e9e 100644
--- a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr
@@ -26,5 +26,5 @@ LL |         inner(ptr, &*ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.tree.stderr b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.tree.stderr
index ef807d7362e..5a8fbe4ce5b 100644
--- a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.tree.stderr
@@ -28,5 +28,5 @@ LL |         inner(ptr, &*ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.stack.stderr b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.stack.stderr
index a5580160c39..be01c5cc840 100644
--- a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.stack.stderr
@@ -22,5 +22,5 @@ LL |         drop(Box::from_raw(ptr as *mut u32));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.tree.stderr b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.tree.stderr
index a5580160c39..be01c5cc840 100644
--- a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.tree.stderr
@@ -22,5 +22,5 @@ LL |         drop(Box::from_raw(ptr as *mut u32));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.stack.stderr b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.stack.stderr
index 23d7fdcd03b..e96e641bb0d 100644
--- a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.stack.stderr
@@ -17,5 +17,5 @@ LL |         drop(Box::from_raw(ptr.as_ptr()));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.tree.stderr b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.tree.stderr
index 23d7fdcd03b..e96e641bb0d 100644
--- a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.tree.stderr
@@ -17,5 +17,5 @@ LL |         drop(Box::from_raw(ptr.as_ptr()));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.stack.stderr b/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.stack.stderr
index 7eb973ae7f2..e78807ec1c8 100644
--- a/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.stack.stderr
@@ -24,5 +24,5 @@ LL |     unsafe { *xraw = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.tree.stderr b/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.tree.stderr
index 9a3618ed85e..5de9c9c1478 100644
--- a/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/load_invalid_shr.tree.stderr
@@ -28,5 +28,5 @@ LL |     unsafe { *xraw = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.stack.stderr b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.stack.stderr
index 3e7fe11b520..264503f2f2f 100644
--- a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.stack.stderr
@@ -34,5 +34,5 @@ LL |     demo_mut_advanced_unique(&mut 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.tree.stderr b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.tree.stderr
index 9cb500679fa..892b1299bbc 100644
--- a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation1.tree.stderr
@@ -38,5 +38,5 @@ LL |     demo_mut_advanced_unique(&mut 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.stack.stderr b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.stack.stderr
index 258189f8878..35d418f574c 100644
--- a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.stack.stderr
@@ -24,5 +24,5 @@ LL |         let raw2 = ptr2.as_mut();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.tree.stderr b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.tree.stderr
index 5d126bdaebf..ca5ac5ac88b 100644
--- a/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/mut_exclusive_violation2.tree.stderr
@@ -28,5 +28,5 @@ LL |         *raw2 = 2;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.stack.stderr b/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.stack.stderr
index fcabb751db9..c26c7f397b0 100644
--- a/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.stack.stderr
@@ -40,5 +40,5 @@ LL | |         )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.tree.stderr b/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.tree.stderr
index 456af0f1eac..3900f5b233e 100644
--- a/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/newtype_pair_retagging.tree.stderr
@@ -51,5 +51,5 @@ LL | |         )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/newtype_retagging.stack.stderr b/src/tools/miri/tests/fail/both_borrows/newtype_retagging.stack.stderr
index 6cbc6a86c09..ae54da70fe2 100644
--- a/src/tools/miri/tests/fail/both_borrows/newtype_retagging.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/newtype_retagging.stack.stderr
@@ -40,5 +40,5 @@ LL | |         )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/newtype_retagging.tree.stderr b/src/tools/miri/tests/fail/both_borrows/newtype_retagging.tree.stderr
index d21ec9eddc2..dd1344a3ce3 100644
--- a/src/tools/miri/tests/fail/both_borrows/newtype_retagging.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/newtype_retagging.tree.stderr
@@ -51,5 +51,5 @@ LL | |         )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/outdated_local.stack.stderr b/src/tools/miri/tests/fail/both_borrows/outdated_local.stack.stderr
index ad366bdabce..9717dd16b5b 100644
--- a/src/tools/miri/tests/fail/both_borrows/outdated_local.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/outdated_local.stack.stderr
@@ -24,5 +24,5 @@ LL |     x = 1; // this invalidates y by reactivating the lowermost uniq borrow
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/outdated_local.tree.stderr b/src/tools/miri/tests/fail/both_borrows/outdated_local.tree.stderr
index 21800d6f4e4..4f79c427b91 100644
--- a/src/tools/miri/tests/fail/both_borrows/outdated_local.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/outdated_local.tree.stderr
@@ -22,5 +22,5 @@ LL |     x = 1; // this invalidates y by reactivating the lowermost uniq borrow
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.stack.stderr b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.stack.stderr
index 5243858a91a..57c4a756cf7 100644
--- a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.stack.stderr
@@ -24,5 +24,5 @@ LL |     unsafe { *xraw = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.tree.stderr b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.tree.stderr
index 677e6eeb483..8060ea9c4a6 100644
--- a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr.tree.stderr
@@ -22,5 +22,5 @@ LL |     unsafe { *xraw = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.stack.stderr b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.stack.stderr
index 26d9f38f239..dfc99ff7cd2 100644
--- a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.stack.stderr
@@ -25,5 +25,5 @@ LL |     unsafe { *xraw = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.tree.stderr b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.tree.stderr
index 242ae0de730..6a92fec38ff 100644
--- a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_option.tree.stderr
@@ -28,5 +28,5 @@ LL |     unsafe { *xraw = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.stack.stderr b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.stack.stderr
index 5f0fbf12759..e4ebe22b60e 100644
--- a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.stack.stderr
@@ -25,5 +25,5 @@ LL |     unsafe { *xraw0 = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.tree.stderr b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.tree.stderr
index 87b9b1361b7..d391c334faf 100644
--- a/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/pass_invalid_shr_tuple.tree.stderr
@@ -28,5 +28,5 @@ LL |     unsafe { *xraw0 = 42 }; // unfreeze
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.stack.stderr b/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.stack.stderr
index 0de2f66fe0b..63eb90b6bc8 100644
--- a/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.stack.stderr
@@ -21,5 +21,5 @@ LL |     let t2 = std::thread::spawn(move || thread_2(p));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.tree.stderr b/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.tree.stderr
index 8036c974eec..f05533a6bb4 100644
--- a/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/retag_data_race_write.tree.stderr
@@ -21,5 +21,5 @@ LL |     let t2 = std::thread::spawn(move || thread_2(p));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr
index d3a73a00fa6..858afa6fb3c 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr
@@ -29,5 +29,5 @@ LL |     foo(&mut (1, 2));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr
index 4c016ea621c..9358520d8ed 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr
@@ -27,5 +27,5 @@ LL |     foo(&mut (1, 2));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr
index 7a9f061228a..ab67bb516ff 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr
@@ -30,5 +30,5 @@ LL |     match foo(&mut (1, 2)) {
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr
index b9ef6dea6ef..d60df19f945 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr
@@ -33,5 +33,5 @@ LL |     match foo(&mut (1, 2)) {
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr
index 6a98c9121ef..22a55f0d37c 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr
@@ -30,5 +30,5 @@ LL |     foo(&mut (1, 2)).0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr
index c3fd124e6cb..b252c691c8d 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr
@@ -33,5 +33,5 @@ LL |     foo(&mut (1, 2)).0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.stack.stderr b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.stack.stderr
index a69116f2afa..52ac2184d49 100644
--- a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.stack.stderr
@@ -29,5 +29,5 @@ LL |     println!("{}", foo(&mut 0));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.tree.stderr b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.tree.stderr
index 9aeaa7ff075..c2025332b9f 100644
--- a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation1.tree.stderr
@@ -32,5 +32,5 @@ LL |     println!("{}", foo(&mut 0));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.stack.stderr b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.stack.stderr
index 0f09359007d..e05ffb3d35e 100644
--- a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.stack.stderr
@@ -24,5 +24,5 @@ LL |         x = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.tree.stderr b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.tree.stderr
index 0269f3ab640..40f2d89850e 100644
--- a/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/shr_frozen_violation2.tree.stderr
@@ -22,5 +22,5 @@ LL |         x = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/box-cell-alias.stderr b/src/tools/miri/tests/fail/box-cell-alias.stderr
index 8c68261aaf7..697cee52d13 100644
--- a/src/tools/miri/tests/fail/box-cell-alias.stderr
+++ b/src/tools/miri/tests/fail/box-cell-alias.stderr
@@ -29,5 +29,5 @@ LL |     let res = helper(val, ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr b/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr
index d68b4b8dfc6..655e682636e 100644
--- a/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr
+++ b/src/tools/miri/tests/fail/branchless-select-i128-pointer.stderr
@@ -15,5 +15,5 @@ LL | |             )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/breakpoint.stderr b/src/tools/miri/tests/fail/breakpoint.stderr
index 8b99c1493b5..1b43c594da4 100644
--- a/src/tools/miri/tests/fail/breakpoint.stderr
+++ b/src/tools/miri/tests/fail/breakpoint.stderr
@@ -8,5 +8,5 @@ LL |         core::intrinsics::breakpoint()
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/concurrency/read_only_atomic_cmpxchg.stderr b/src/tools/miri/tests/fail/concurrency/read_only_atomic_cmpxchg.stderr
index fc5982e7f94..f3e1796f3c9 100644
--- a/src/tools/miri/tests/fail/concurrency/read_only_atomic_cmpxchg.stderr
+++ b/src/tools/miri/tests/fail/concurrency/read_only_atomic_cmpxchg.stderr
@@ -13,5 +13,5 @@ see <https://doc.rust-lang.org/nightly/std/sync/atomic/index.html#atomic-accesse
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_acquire.stderr b/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_acquire.stderr
index 2945344877a..2f873ce1ae7 100644
--- a/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_acquire.stderr
+++ b/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_acquire.stderr
@@ -15,5 +15,5 @@ see <https://doc.rust-lang.org/nightly/std/sync/atomic/index.html#atomic-accesse
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/const-ub-checks.stderr b/src/tools/miri/tests/fail/const-ub-checks.stderr
index 29acc642c14..700a96a9062 100644
--- a/src/tools/miri/tests/fail/const-ub-checks.stderr
+++ b/src/tools/miri/tests/fail/const-ub-checks.stderr
@@ -10,6 +10,6 @@ note: erroneous constant encountered
 LL |     let _x = UNALIGNED_READ;
    |              ^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/src/tools/miri/tests/fail/coroutine-pinned-moved.stderr b/src/tools/miri/tests/fail/coroutine-pinned-moved.stderr
index 919fa87f9d7..b5b0cbb04e0 100644
--- a/src/tools/miri/tests/fail/coroutine-pinned-moved.stderr
+++ b/src/tools/miri/tests/fail/coroutine-pinned-moved.stderr
@@ -32,5 +32,5 @@ LL |     coroutine_iterator_2.next(); // and use moved value
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref.stderr
index 33d640759fd..d7fa84e0ca1 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref.stderr
@@ -21,5 +21,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref_match_never.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref_match_never.stderr
index 2ca6fd028b0..7d38a5649a5 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref_match_never.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_deref_match_never.stderr
@@ -11,5 +11,5 @@ LL |         match *p {}
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_offset.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_offset.stderr
index 7ef5fd329a4..b9fbadb1f89 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_offset.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_offset.stderr
@@ -21,5 +21,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let.stderr
index 16841626dc2..05e8c95166c 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let.stderr
@@ -21,5 +21,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let_type_annotation.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let_type_annotation.stderr
index 0cdb6639a2f..8f7ba156a93 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let_type_annotation.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_let_type_annotation.stderr
@@ -21,5 +21,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_match.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_match.stderr
index 625a7b5f60b..c2b5d7b23cb 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_match.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_project_underscore_match.stderr
@@ -21,5 +21,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
index c2a73bfbcb2..ee02c1040c7 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
@@ -22,5 +22,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr
index d8cb691e553..72b9a4a2d6c 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr
@@ -21,5 +21,5 @@ LL |     };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/deref-invalid-ptr.stderr b/src/tools/miri/tests/fail/dangling_pointers/deref-invalid-ptr.stderr
index f11863b5067..377022fa97f 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/deref-invalid-ptr.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/deref-invalid-ptr.stderr
@@ -11,5 +11,5 @@ LL |     let _y = unsafe { &*x as *const u32 };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr
index 64d6d36c2c0..eb4482f5cae 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_box.stderr
@@ -12,5 +12,5 @@ LL |     let _val = unsafe { addr_of_mut!(**outer) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr
index 244e3f4b659..c0d989dc1a0 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/deref_dangling_ref.stderr
@@ -12,5 +12,5 @@ LL |     let _val = unsafe { addr_of_mut!(**outer) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr b/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr
index 4d45630e1ba..7d43857b9bf 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/dyn_size.stderr
@@ -11,5 +11,5 @@ LL |     let _ptr = unsafe { &*ptr };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr
index 895d4c7fce2..13c53e20b8a 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr
@@ -11,5 +11,5 @@ LL |     let _x: () = unsafe { *ptr };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr
index 6cc05758b7e..e4e23e8ace1 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { *ptr = zst_val };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref.stderr b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref.stderr
index 727c724552d..a18f0f20fc0 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref.stderr
@@ -11,5 +11,5 @@ LL |     let x: i32 = unsafe { *std::ptr::null() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr
index 9f93a0e18a2..1a8794f3ceb 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr
@@ -11,5 +11,5 @@ LL |     let x: () = unsafe { *std::ptr::null() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write.stderr b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write.stderr
index 6974b997725..01d4d12a002 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { *std::ptr::null_mut() = 0i32 };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr
index 2953d85c25f..1d4704e2a0e 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { std::ptr::null_mut::<[u8; 0]>().write(zst_val) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_project.stderr b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_project.stderr
index 1c105991015..4195c68d500 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_project.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_project.stderr
@@ -17,5 +17,5 @@ LL |     let v = 0u32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read.stderr b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read.stderr
index 38d691f4c01..37dbea37ce2 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read.stderr
@@ -17,5 +17,5 @@ LL |     let v: Vec<u16> = vec![1, 2];
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_write.stderr b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_write.stderr
index 9669614d47f..97b3f3ebe7b 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_write.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_write.stderr
@@ -17,5 +17,5 @@ LL |     let mut v: Vec<u16> = vec![1, 2];
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/stack_temporary.stderr b/src/tools/miri/tests/fail/dangling_pointers/stack_temporary.stderr
index 28a9207cff3..d5c53e4ad64 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/stack_temporary.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/stack_temporary.stderr
@@ -21,5 +21,5 @@ LL |         let x = make_ref(&mut 0); // The temporary storing "0" is deallocat
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/storage_dead_dangling.stderr b/src/tools/miri/tests/fail/dangling_pointers/storage_dead_dangling.stderr
index 9b47655a047..27e5a865069 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/storage_dead_dangling.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/storage_dead_dangling.stderr
@@ -16,5 +16,5 @@ LL |     evil();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dangling_pointers/wild_pointer_deref.stderr b/src/tools/miri/tests/fail/dangling_pointers/wild_pointer_deref.stderr
index 802995aea50..b7492a09dd0 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/wild_pointer_deref.stderr
+++ b/src/tools/miri/tests/fail/dangling_pointers/wild_pointer_deref.stderr
@@ -11,5 +11,5 @@ LL |     let x = unsafe { *p };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/alloc_read_race.stderr b/src/tools/miri/tests/fail/data_race/alloc_read_race.stderr
index 9d21a3e0a45..fb0f77d2e6f 100644
--- a/src/tools/miri/tests/fail/data_race/alloc_read_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/alloc_read_race.stderr
@@ -16,5 +16,5 @@ LL |             pointer.store(Box::into_raw(Box::new_uninit()), Ordering::Relax
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/alloc_write_race.stderr b/src/tools/miri/tests/fail/data_race/alloc_write_race.stderr
index 13a19109e88..7e6edc02bc2 100644
--- a/src/tools/miri/tests/fail/data_race/alloc_write_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/alloc_write_race.stderr
@@ -16,5 +16,5 @@ LL |                 .store(Box::into_raw(Box::<usize>::new_uninit()) as *mut us
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race1.stderr b/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race1.stderr
index f55f839d0b8..04186f7ff7b 100644
--- a/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race1.stderr
@@ -16,5 +16,5 @@ LL |             *(c.0 as *mut usize) = 32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race2.stderr b/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race2.stderr
index a20c220b6c2..7e76205da9c 100644
--- a/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race2.stderr
+++ b/src/tools/miri/tests/fail/data_race/atomic_read_na_write_race2.stderr
@@ -16,5 +16,5 @@ LL |             atomic_ref.load(Ordering::SeqCst)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race1.stderr b/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race1.stderr
index a91d4cee054..69d11a0a83c 100644
--- a/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race1.stderr
@@ -16,5 +16,5 @@ LL |             atomic_ref.store(32, Ordering::SeqCst)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race2.stderr b/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race2.stderr
index 8831d9cfc1c..4f734ae5465 100644
--- a/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race2.stderr
+++ b/src/tools/miri/tests/fail/data_race/atomic_write_na_read_race2.stderr
@@ -16,5 +16,5 @@ LL |             let _val = *(c.0 as *mut usize);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race1.stderr b/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race1.stderr
index 5aed907b166..8745048df47 100644
--- a/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race1.stderr
@@ -16,5 +16,5 @@ LL |             *(c.0 as *mut usize) = 32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race2.stderr b/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race2.stderr
index 65114296f52..7ee50143124 100644
--- a/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race2.stderr
+++ b/src/tools/miri/tests/fail/data_race/atomic_write_na_write_race2.stderr
@@ -16,5 +16,5 @@ LL |             atomic_ref.store(64, Ordering::SeqCst);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dangling_thread_async_race.stderr b/src/tools/miri/tests/fail/data_race/dangling_thread_async_race.stderr
index 7ac3a9cc929..deb6029577f 100644
--- a/src/tools/miri/tests/fail/data_race/dangling_thread_async_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/dangling_thread_async_race.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dangling_thread_race.stderr b/src/tools/miri/tests/fail/data_race/dangling_thread_race.stderr
index 49256dff51f..f8ede3ac4c8 100644
--- a/src/tools/miri/tests/fail/data_race/dangling_thread_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/dangling_thread_race.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr b/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr
index ef6b0c3616b..55b0b447213 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr
@@ -21,5 +21,5 @@ LL |             let _val = *ptr.0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_read_race2.stderr b/src/tools/miri/tests/fail/data_race/dealloc_read_race2.stderr
index 792faf8f5d1..8925de139b4 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_read_race2.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_read_race2.stderr
@@ -25,5 +25,5 @@ LL | |             )
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr b/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr
index 805d7c19642..b9aa4bb041b 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr
@@ -16,5 +16,5 @@ LL |             *pointer.load(Ordering::Acquire)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr b/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr
index 22ef35959f2..0af2911223f 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr
@@ -21,5 +21,5 @@ LL |             *ptr.0 = 2;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_write_race2.stderr b/src/tools/miri/tests/fail/data_race/dealloc_write_race2.stderr
index 64f654402d7..6ab77de8afe 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_write_race2.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_write_race2.stderr
@@ -25,5 +25,5 @@ LL | |             );
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr b/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr
index 52c9abd5fe0..c1471ae5583 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr
@@ -16,5 +16,5 @@ LL |             *pointer.load(Ordering::Acquire) = 3;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/enable_after_join_to_main.stderr b/src/tools/miri/tests/fail/data_race/enable_after_join_to_main.stderr
index 1d8bf2d0d26..e51119ddb2f 100644
--- a/src/tools/miri/tests/fail/data_race/enable_after_join_to_main.stderr
+++ b/src/tools/miri/tests/fail/data_race/enable_after_join_to_main.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/fence_after_load.stderr b/src/tools/miri/tests/fail/data_race/fence_after_load.stderr
index 17bcf24a505..0b71a41098a 100644
--- a/src/tools/miri/tests/fail/data_race/fence_after_load.stderr
+++ b/src/tools/miri/tests/fail/data_race/fence_after_load.stderr
@@ -16,5 +16,5 @@ LL |         unsafe { V = 1 }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/mixed_size_read.stderr b/src/tools/miri/tests/fail/data_race/mixed_size_read.stderr
index 8988655208a..acbc2306726 100644
--- a/src/tools/miri/tests/fail/data_race/mixed_size_read.stderr
+++ b/src/tools/miri/tests/fail/data_race/mixed_size_read.stderr
@@ -18,5 +18,5 @@ LL |             a16.load(Ordering::SeqCst);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/mixed_size_write.stderr b/src/tools/miri/tests/fail/data_race/mixed_size_write.stderr
index 55c9011f1b4..761942cbad3 100644
--- a/src/tools/miri/tests/fail/data_race/mixed_size_write.stderr
+++ b/src/tools/miri/tests/fail/data_race/mixed_size_write.stderr
@@ -18,5 +18,5 @@ LL |             a16.store(1, Ordering::SeqCst);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/read_read_race1.stderr b/src/tools/miri/tests/fail/data_race/read_read_race1.stderr
index e1009472fee..d2ba738f0b9 100644
--- a/src/tools/miri/tests/fail/data_race/read_read_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/read_read_race1.stderr
@@ -18,5 +18,5 @@ LL |             unsafe { ptr.read() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/read_read_race2.stderr b/src/tools/miri/tests/fail/data_race/read_read_race2.stderr
index 22017ae633d..8ac0446fccd 100644
--- a/src/tools/miri/tests/fail/data_race/read_read_race2.stderr
+++ b/src/tools/miri/tests/fail/data_race/read_read_race2.stderr
@@ -18,5 +18,5 @@ LL |             a.load(Ordering::SeqCst);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/read_write_race.stderr b/src/tools/miri/tests/fail/data_race/read_write_race.stderr
index c3fdcdf9308..0066a11188b 100644
--- a/src/tools/miri/tests/fail/data_race/read_write_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/read_write_race.stderr
@@ -16,5 +16,5 @@ LL |             let _val = *c.0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/read_write_race_stack.stderr b/src/tools/miri/tests/fail/data_race/read_write_race_stack.stderr
index 1e45878bfdd..35f63af2dc5 100644
--- a/src/tools/miri/tests/fail/data_race/read_write_race_stack.stderr
+++ b/src/tools/miri/tests/fail/data_race/read_write_race_stack.stderr
@@ -16,5 +16,5 @@ LL |             *pointer.load(Ordering::Acquire) = 3;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/relax_acquire_race.stderr b/src/tools/miri/tests/fail/data_race/relax_acquire_race.stderr
index 0c574299b69..6cd232ac3d4 100644
--- a/src/tools/miri/tests/fail/data_race/relax_acquire_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/relax_acquire_race.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/release_seq_race.stderr b/src/tools/miri/tests/fail/data_race/release_seq_race.stderr
index 9aff6c6c3a7..61121bb8347 100644
--- a/src/tools/miri/tests/fail/data_race/release_seq_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/release_seq_race.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/release_seq_race_same_thread.stderr b/src/tools/miri/tests/fail/data_race/release_seq_race_same_thread.stderr
index f0522404fde..d674b30c770 100644
--- a/src/tools/miri/tests/fail/data_race/release_seq_race_same_thread.stderr
+++ b/src/tools/miri/tests/fail/data_race/release_seq_race_same_thread.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/rmw_race.stderr b/src/tools/miri/tests/fail/data_race/rmw_race.stderr
index b400b2b9a17..eeaada1b0f3 100644
--- a/src/tools/miri/tests/fail/data_race/rmw_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/rmw_race.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/stack_pop_race.stderr b/src/tools/miri/tests/fail/data_race/stack_pop_race.stderr
index e6804f6520c..2cef51ec94b 100644
--- a/src/tools/miri/tests/fail/data_race/stack_pop_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/stack_pop_race.stderr
@@ -21,5 +21,5 @@ LL |     race(0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/write_write_race.stderr b/src/tools/miri/tests/fail/data_race/write_write_race.stderr
index bc793e9afb0..ca32984be2f 100644
--- a/src/tools/miri/tests/fail/data_race/write_write_race.stderr
+++ b/src/tools/miri/tests/fail/data_race/write_write_race.stderr
@@ -16,5 +16,5 @@ LL |             *c.0 = 32;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/data_race/write_write_race_stack.stderr b/src/tools/miri/tests/fail/data_race/write_write_race_stack.stderr
index ea62dbf96b9..038e9079c54 100644
--- a/src/tools/miri/tests/fail/data_race/write_write_race_stack.stderr
+++ b/src/tools/miri/tests/fail/data_race/write_write_race_stack.stderr
@@ -16,5 +16,5 @@ LL |             *pointer.load(Ordering::Acquire) = 3;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr b/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr
index 03272105c41..365186bcc4b 100644
--- a/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr
+++ b/src/tools/miri/tests/fail/dyn-call-trait-mismatch.stderr
@@ -11,5 +11,5 @@ LL |     r2.method2();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr b/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr
index 21870ef3733..8bac908b864 100644
--- a/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr
+++ b/src/tools/miri/tests/fail/dyn-upcast-trait-mismatch.stderr
@@ -11,5 +11,5 @@ LL |     let _err = baz_fake as &dyn Foo;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/environ-gets-deallocated.stderr b/src/tools/miri/tests/fail/environ-gets-deallocated.stderr
index dd7420906d3..c9bda00493e 100644
--- a/src/tools/miri/tests/fail/environ-gets-deallocated.stderr
+++ b/src/tools/miri/tests/fail/environ-gets-deallocated.stderr
@@ -11,5 +11,5 @@ LL |     let _y = unsafe { *pointer };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/erroneous_const.stderr b/src/tools/miri/tests/fail/erroneous_const.stderr
index cacf866393d..ab036247a31 100644
--- a/src/tools/miri/tests/fail/erroneous_const.stderr
+++ b/src/tools/miri/tests/fail/erroneous_const.stderr
@@ -12,6 +12,6 @@ note: erroneous constant encountered
 LL |         let _ = PrintName::<T>::VOID;
    |                 ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/src/tools/miri/tests/fail/erroneous_const2.stderr b/src/tools/miri/tests/fail/erroneous_const2.stderr
index 36e83b8f3bc..47b06fa8aaa 100644
--- a/src/tools/miri/tests/fail/erroneous_const2.stderr
+++ b/src/tools/miri/tests/fail/erroneous_const2.stderr
@@ -18,6 +18,6 @@ LL |     println!("{}", FOO);
    |
    = note: this note originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/src/tools/miri/tests/fail/extern_static.stderr b/src/tools/miri/tests/fail/extern_static.stderr
index fa0d55e5f67..c3de4dadb0a 100644
--- a/src/tools/miri/tests/fail/extern_static.stderr
+++ b/src/tools/miri/tests/fail/extern_static.stderr
@@ -10,5 +10,5 @@ LL |     let _val = unsafe { std::ptr::addr_of!(FOO) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/extern_static_in_const.stderr b/src/tools/miri/tests/fail/extern_static_in_const.stderr
index e4ee8f1acba..23f775f2588 100644
--- a/src/tools/miri/tests/fail/extern_static_in_const.stderr
+++ b/src/tools/miri/tests/fail/extern_static_in_const.stderr
@@ -10,5 +10,5 @@ LL |     let _val = X;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/extern_static_wrong_size.stderr b/src/tools/miri/tests/fail/extern_static_wrong_size.stderr
index a56eba09df9..c935a548f80 100644
--- a/src/tools/miri/tests/fail/extern_static_wrong_size.stderr
+++ b/src/tools/miri/tests/fail/extern_static_wrong_size.stderr
@@ -10,5 +10,5 @@ LL |     let _val = unsafe { environ };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/fast_math_both.stderr b/src/tools/miri/tests/fail/fast_math_both.stderr
index 2a0759f8a3b..feba0c5991c 100644
--- a/src/tools/miri/tests/fail/fast_math_both.stderr
+++ b/src/tools/miri/tests/fail/fast_math_both.stderr
@@ -11,5 +11,5 @@ LL | ...: f32 = core::intrinsics::fsub_fast(f32::NAN, f32::NAN);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/fast_math_first.stderr b/src/tools/miri/tests/fail/fast_math_first.stderr
index 766662ca14b..b26b5a37215 100644
--- a/src/tools/miri/tests/fail/fast_math_first.stderr
+++ b/src/tools/miri/tests/fail/fast_math_first.stderr
@@ -11,5 +11,5 @@ LL | ...   let _x: f32 = core::intrinsics::frem_fast(f32::NAN, 3.2);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/fast_math_second.stderr b/src/tools/miri/tests/fail/fast_math_second.stderr
index ce93f9398f2..cb46aa97a8d 100644
--- a/src/tools/miri/tests/fail/fast_math_second.stderr
+++ b/src/tools/miri/tests/fail/fast_math_second.stderr
@@ -11,5 +11,5 @@ LL | ...f32 = core::intrinsics::fmul_fast(3.4f32, f32::INFINITY);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr
index ccf9732ed07..1756123c84e 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.stack.stderr
@@ -33,5 +33,5 @@ LL |             Call(_unit = callee(Move(*ptr), ptr), after_call, UnwindContinu
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
index e7baf6e23db..76f7ee189e3 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
@@ -41,5 +41,5 @@ LL |             Call(_unit = callee(Move(*ptr), ptr), after_call, UnwindContinu
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr
index 5d9a3af0c8a..2cd9966bbf5 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr
@@ -11,5 +11,5 @@ LL |             _observe = non_copy.0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr
index f8140d0236a..723ca75daef 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr
@@ -16,5 +16,5 @@ LL |             Call(_unit = change_arg(Move(*ptr), ptr), after_call, UnwindCon
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr
index c37e788e6b4..401e8c6d5a8 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.stack.stderr
@@ -33,5 +33,5 @@ LL |             Call(_unit = change_arg(Move(*ptr), ptr), after_call, UnwindCon
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
index 7557d3710d1..3529ddd3c53 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
@@ -41,5 +41,5 @@ LL |             Call(_unit = change_arg(Move(*ptr), ptr), after_call, UnwindCon
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_abi.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_abi.stderr
index 406ccb070ba..2f24425ed1d 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_abi.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_abi.stderr
@@ -11,5 +11,5 @@ LL |         let _ = malloc(0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr
index d90a7e31d6e..d475801f41c 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr
@@ -11,5 +11,5 @@ LL |         abort(1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr
index 9e2751a216b..ad952804ecc 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr
@@ -11,5 +11,5 @@ LL |         let _ = malloc();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr
index e9a38b5ae42..3b1df8a9d42 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr
@@ -11,5 +11,5 @@ LL |         let _ = malloc(1, 2);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/check_callback_abi.stderr b/src/tools/miri/tests/fail/function_calls/check_callback_abi.stderr
index 50afc109797..f948d08bdbe 100644
--- a/src/tools/miri/tests/fail/function_calls/check_callback_abi.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_callback_abi.stderr
@@ -16,5 +16,5 @@ LL | |         );
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.cache.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.cache.stderr
index ae5c6cb72b3..2feba7d8e34 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.cache.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.cache.stderr
@@ -11,5 +11,5 @@ LL |             foo();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.fn_ptr.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.fn_ptr.stderr
index 17d56793ac5..0537508babd 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.fn_ptr.stderr
@@ -11,5 +11,5 @@ LL |         std::mem::transmute::<unsafe fn(), unsafe extern "C" fn()>(foo)();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.no_cache.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.no_cache.stderr
index ae5c6cb72b3..2feba7d8e34 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.no_cache.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_abi_mismatch.no_cache.stderr
@@ -11,5 +11,5 @@ LL |             foo();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
index 507b459b718..c5ca1274574 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
@@ -16,5 +16,5 @@ LL |     unsafe { unwind() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
index 4c477416416..2be02100a35 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
@@ -33,5 +33,5 @@ LL |     unsafe { nounwind() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
index 4c477416416..2be02100a35 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
@@ -33,5 +33,5 @@ LL |     unsafe { nounwind() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
index 25e13d74754..f89cee0b863 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
@@ -14,5 +14,5 @@ LL |     unsafe { nounwind() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_clashing.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_clashing.stderr
index 09e4157b31f..2f561ed88e3 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_clashing.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_clashing.stderr
@@ -19,5 +19,5 @@ LL | fn bar() {}
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_shim_clashing.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_shim_clashing.stderr
index 0d0055bb85c..d51156b3c33 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_shim_clashing.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_shim_clashing.stderr
@@ -17,5 +17,5 @@ LL | | }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr
index 1aa13ce4389..69b710b3d3b 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_arguments.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { foo(1) }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_type.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_type.stderr
index abfd7a9a6c4..96b483059b0 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_type.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_wrong_type.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { FOO() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.none.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.none.stderr
index dd951066c32..48db898a250 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.none.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.none.stderr
@@ -16,5 +16,5 @@ LL |             Call(*ptr = myfun(ptr), after_call, UnwindContinue())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.stack.stderr
index cf13be6da01..85dcd29ba55 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.stack.stderr
@@ -33,5 +33,5 @@ LL |             Call(*ptr = myfun(ptr), after_call, UnwindContinue())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.tree.stderr
index e16c4c0ebb6..ea1867b1a71 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.tree.stderr
@@ -41,5 +41,5 @@ LL |             Call(*ptr = myfun(ptr), after_call, UnwindContinue())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.stack.stderr
index 5d76d9eab67..12a99fbf293 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.stack.stderr
@@ -36,5 +36,5 @@ LL |             Call(_x = myfun(ptr), after_call, UnwindContinue())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.tree.stderr
index e8165a73ff4..926303bb489 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.tree.stderr
@@ -41,5 +41,5 @@ LL |             Call(_x = myfun(ptr), after_call, UnwindContinue())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
index ecd9a111840..7f035eb5e85 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
@@ -15,5 +15,5 @@ LL |     dbg!(x.0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/simd_feature_flag_difference.stderr b/src/tools/miri/tests/fail/function_calls/simd_feature_flag_difference.stderr
index ab3ff5fcdc1..2544421c7e8 100644
--- a/src/tools/miri/tests/fail/function_calls/simd_feature_flag_difference.stderr
+++ b/src/tools/miri/tests/fail/function_calls/simd_feature_flag_difference.stderr
@@ -16,5 +16,5 @@ LL |     let copy = bar(input);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_calls/target_feature.stderr b/src/tools/miri/tests/fail/function_calls/target_feature.stderr
index bddc6e7e89b..4d3cf6e9d3b 100644
--- a/src/tools/miri/tests/fail/function_calls/target_feature.stderr
+++ b/src/tools/miri/tests/fail/function_calls/target_feature.stderr
@@ -11,5 +11,5 @@ LL |         ssse3_fn();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
index d1ccaf89974..595235088f6 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
@@ -13,5 +13,5 @@ LL |     g(Default::default())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
index 3875c2617bb..a8b1cf40c04 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
@@ -13,5 +13,5 @@ LL |     g(42)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
index 6d1bdfee007..60dd3814bf5 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
@@ -13,5 +13,5 @@ LL |     g(&42 as *const i32)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
index 07d76c90e5e..198896b0dd7 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
@@ -13,5 +13,5 @@ LL |     g()
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
index 7ac2bc2739f..daf216a142c 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
@@ -13,5 +13,5 @@ LL |     g(42)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr
index 558d83bcfd2..2e50d054e77 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_few_args.stderr
@@ -11,5 +11,5 @@ LL |     g()
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr
index dc12073952f..facfe9d31f2 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_too_many_args.stderr
@@ -11,5 +11,5 @@ LL |     g(42)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
index e082eb9e3e3..50f4474cc0e 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
@@ -13,5 +13,5 @@ LL |     g(Default::default())
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/cast_box_int_to_fn_ptr.stderr b/src/tools/miri/tests/fail/function_pointers/cast_box_int_to_fn_ptr.stderr
index ad43c2c9d3f..f95a62535d8 100644
--- a/src/tools/miri/tests/fail/function_pointers/cast_box_int_to_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/cast_box_int_to_fn_ptr.stderr
@@ -11,5 +11,5 @@ LL |     (*g)(42)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/cast_int_to_fn_ptr.stderr b/src/tools/miri/tests/fail/function_pointers/cast_int_to_fn_ptr.stderr
index 81fc9716a41..7274f62b4d7 100644
--- a/src/tools/miri/tests/fail/function_pointers/cast_int_to_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/cast_int_to_fn_ptr.stderr
@@ -11,5 +11,5 @@ LL |     g(42)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/deref_fn_ptr.stderr b/src/tools/miri/tests/fail/function_pointers/deref_fn_ptr.stderr
index 954bb8721e7..b5cee95d66d 100644
--- a/src/tools/miri/tests/fail/function_pointers/deref_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/deref_fn_ptr.stderr
@@ -11,5 +11,5 @@ LL |         *std::mem::transmute::<fn(), *const u8>(f)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/execute_memory.stderr b/src/tools/miri/tests/fail/function_pointers/execute_memory.stderr
index 10c53ca2bea..4370e6d6a29 100644
--- a/src/tools/miri/tests/fail/function_pointers/execute_memory.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/execute_memory.stderr
@@ -11,5 +11,5 @@ LL |         f()
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/function_pointers/fn_ptr_offset.stderr b/src/tools/miri/tests/fail/function_pointers/fn_ptr_offset.stderr
index f8c519c1b54..e66ab681860 100644
--- a/src/tools/miri/tests/fail/function_pointers/fn_ptr_offset.stderr
+++ b/src/tools/miri/tests/fail/function_pointers/fn_ptr_offset.stderr
@@ -11,5 +11,5 @@ LL |     x();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/assume.stderr b/src/tools/miri/tests/fail/intrinsics/assume.stderr
index c1909570d99..7fa6f7b5bfc 100644
--- a/src/tools/miri/tests/fail/intrinsics/assume.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/assume.stderr
@@ -11,5 +11,5 @@ LL |         std::intrinsics::assume(x > 42);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_null.stderr b/src/tools/miri/tests/fail/intrinsics/copy_null.stderr
index 6e3215d9f1c..d73c03475d6 100644
--- a/src/tools/miri/tests/fail/intrinsics/copy_null.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/copy_null.stderr
@@ -11,5 +11,5 @@ LL |         copy_nonoverlapping(std::ptr::null(), ptr, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_overflow.stderr b/src/tools/miri/tests/fail/intrinsics/copy_overflow.stderr
index 23a4adbd0ed..b7c92cf4a57 100644
--- a/src/tools/miri/tests/fail/intrinsics/copy_overflow.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/copy_overflow.stderr
@@ -11,5 +11,5 @@ LL |         (&mut y as *mut i32).copy_from(&x, 1usize << (mem::size_of::<usize>
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_overlapping.stderr b/src/tools/miri/tests/fail/intrinsics/copy_overlapping.stderr
index 13a76aae730..e9ea262caf7 100644
--- a/src/tools/miri/tests/fail/intrinsics/copy_overlapping.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/copy_overlapping.stderr
@@ -11,5 +11,5 @@ LL |         copy_nonoverlapping(a, b, 2);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr b/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr
index a275979e6be..d190f3de6b8 100644
--- a/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr
@@ -11,5 +11,5 @@ LL |         copy_nonoverlapping(&data[5], ptr, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ctlz_nonzero.stderr b/src/tools/miri/tests/fail/intrinsics/ctlz_nonzero.stderr
index 5ae14472a8a..9889daaa851 100644
--- a/src/tools/miri/tests/fail/intrinsics/ctlz_nonzero.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ctlz_nonzero.stderr
@@ -11,5 +11,5 @@ LL |         ctlz_nonzero(0u8);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/cttz_nonzero.stderr b/src/tools/miri/tests/fail/intrinsics/cttz_nonzero.stderr
index ae013fb3d97..0f75657e170 100644
--- a/src/tools/miri/tests/fail/intrinsics/cttz_nonzero.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/cttz_nonzero.stderr
@@ -11,5 +11,5 @@ LL |         cttz_nonzero(0u8);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/div-by-zero.stderr b/src/tools/miri/tests/fail/intrinsics/div-by-zero.stderr
index 8c2910de3ee..9f66e63ca5c 100644
--- a/src/tools/miri/tests/fail/intrinsics/div-by-zero.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/div-by-zero.stderr
@@ -11,5 +11,5 @@ LL |         let _n = unchecked_div(1i64, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/exact_div1.stderr b/src/tools/miri/tests/fail/intrinsics/exact_div1.stderr
index 2c7bbc00e1b..ca6125ab899 100644
--- a/src/tools/miri/tests/fail/intrinsics/exact_div1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/exact_div1.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { std::intrinsics::exact_div(2, 0) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/exact_div2.stderr b/src/tools/miri/tests/fail/intrinsics/exact_div2.stderr
index 6a264b8b447..306e9bdc238 100644
--- a/src/tools/miri/tests/fail/intrinsics/exact_div2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/exact_div2.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { std::intrinsics::exact_div(2u16, 3) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/exact_div3.stderr b/src/tools/miri/tests/fail/intrinsics/exact_div3.stderr
index 1a73822c300..cbcb093a4e6 100644
--- a/src/tools/miri/tests/fail/intrinsics/exact_div3.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/exact_div3.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { std::intrinsics::exact_div(-19i8, 2) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/exact_div4.stderr b/src/tools/miri/tests/fail/intrinsics/exact_div4.stderr
index 27201d9c7cf..1b903bc97ae 100644
--- a/src/tools/miri/tests/fail/intrinsics/exact_div4.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/exact_div4.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { std::intrinsics::exact_div(i64::MIN, -1) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_inf1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_inf1.stderr
index c82d6b30224..560771bc24f 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_inf1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_inf1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, i32>(f32::INFINITY);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_infneg1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_infneg1.stderr
index 4ca41b676e9..ae78af3dcbd 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_infneg1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_infneg1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, i32>(f32::NEG_INFINITY);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nan.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nan.stderr
index 88b8948b0c2..2db3efeaac1 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nan.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nan.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, u32>(f32::NAN);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nanneg.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nanneg.stderr
index ca798dd391a..769c35255bb 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nanneg.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_nanneg.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, u32>(-f32::NAN);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_neg.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_neg.stderr
index 4ff6eb80985..55df31dddd8 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_neg.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_neg.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, u32>(-1.000000001f32);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big1.stderr
index fd17709d164..7a87de7b3b3 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, i32>(2147483648.0f32);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big2.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big2.stderr
index fdc1f65dc14..6be9b4924b0 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big2.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, u32>((u32::MAX - 127) as f32);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_small1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_small1.stderr
index 9e743a32144..5a467f39d92 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_small1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_small1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f32, i32>(-2147483904.0f32);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_inf1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_inf1.stderr
index ee01143dc8d..5cbf1912139 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_inf1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_inf1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u128>(f64::INFINITY);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg1.stderr
index f37b8ae5506..4a4d71f53ed 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u128>(f64::NEG_INFINITY);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg2.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg2.stderr
index 05dcd5ebcf6..1f970b3985c 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg2.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i128>(f64::NEG_INFINITY);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_nan.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_nan.stderr
index 0a914abb2ce..85e9aa87a9b 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_nan.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_nan.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u32>(f64::NAN);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_neg.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_neg.stderr
index ddf3249d059..a8f495f7048 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_neg.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_neg.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u128>(-1.0000000000001f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big1.stderr
index 42da33321f3..3da8bdf9238 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i32>(2147483648.0f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big2.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big2.stderr
index af4c4ceb3f7..57383892c3d 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big2.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i64>(9223372036854775808.0f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big3.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big3.stderr
index 6e384a6fbc7..7558fafd973 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big3.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big3.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u64>(18446744073709551616.0f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big4.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big4.stderr
index 77f05ff91e3..d01c19b7391 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big4.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big4.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u128>(u128::MAX as f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big5.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big5.stderr
index cb5eba490b4..0af13b8bbf3 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big5.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big5.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i128>(2402823669209384634633746074317
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big6.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big6.stderr
index d899d2f808a..a99bbe15825 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big6.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big6.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, u128>(f64::MAX);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big7.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big7.stderr
index 443b2759c26..cef4acee688 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big7.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big7.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i128>(f64::MIN);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small1.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small1.stderr
index f8d88c44aa8..0823e84aaf9 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small1.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i32>(-2147483649.0f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small2.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small2.stderr
index d94e57b1e67..3260faab780 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small2.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i64>(-9223372036854777856.0f64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small3.stderr b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small3.stderr
index 59b74f5f51f..4f64fabc331 100644
--- a/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small3.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small3.stderr
@@ -11,5 +11,5 @@ LL |         float_to_int_unchecked::<f64, i128>(-240282366920938463463374607431
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_1.stderr b/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_1.stderr
index e1102a6d216..cc8cca70ddb 100644
--- a/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_1.stderr
@@ -16,5 +16,5 @@ LL |     let v = [0i8; 4];
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_2.stderr b/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_2.stderr
index 6a11ebae108..97fa1f19af1 100644
--- a/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_2.stderr
@@ -11,5 +11,5 @@ LL |     let x = unsafe { x.offset(isize::MIN) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_3.stderr b/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_3.stderr
index 99f28b3e4f8..236b51e82e5 100644
--- a/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_3.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/out_of_bounds_ptr_3.stderr
@@ -16,5 +16,5 @@ LL |     let v = [0i8; 4];
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr
index 9c1c387d549..a8984c7fa16 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr
@@ -11,5 +11,5 @@ LL |     let _x = unsafe { x.offset(0) }; // UB despite offset 0, NULL is never
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr
index 0b9cda62b33..32a4461d6bf 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { end_ptr.offset_from(end_ptr) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_unsigned_neg.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_unsigned_neg.stderr
index 803aaaa55c2..0b4a9faf1b2 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_unsigned_neg.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_unsigned_neg.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { ptr1.sub_ptr(ptr2) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_int.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_int.stderr
index f76881011d0..e03abfb1a2f 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_int.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_int.stderr
@@ -11,5 +11,5 @@ LL |         let _val = (1 as *mut u8).offset(1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_ptr.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_ptr.stderr
index 6e0744b7d5c..03ae9bd141c 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_ptr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_int_plus_ptr.stderr
@@ -11,5 +11,5 @@ LL |         let _val = (1 as *mut u8).offset(ptr as isize);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_overflow.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_overflow.stderr
index 6fb94cf5f81..122529c3049 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_overflow.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_overflow.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { x.offset(isize::MIN) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr
index 7cc4bc184a1..304d362bbb9 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr
@@ -16,5 +16,5 @@ LL |     let x = Box::into_raw(Box::new(0u32));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/raw_eq_on_ptr.stderr b/src/tools/miri/tests/fail/intrinsics/raw_eq_on_ptr.stderr
index 2236ad9839c..83f81fa726e 100644
--- a/src/tools/miri/tests/fail/intrinsics/raw_eq_on_ptr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/raw_eq_on_ptr.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { raw_eq(&x, &x) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/rem-by-zero.stderr b/src/tools/miri/tests/fail/intrinsics/rem-by-zero.stderr
index 1fc39188e5a..9b9fe4da139 100644
--- a/src/tools/miri/tests/fail/intrinsics/rem-by-zero.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/rem-by-zero.stderr
@@ -11,5 +11,5 @@ LL |         let _n = unchecked_rem(3u32, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-div-by-zero.stderr b/src/tools/miri/tests/fail/intrinsics/simd-div-by-zero.stderr
index ddab24d0c16..44d3749d682 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-div-by-zero.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-div-by-zero.stderr
@@ -11,5 +11,5 @@ LL |         simd_div(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-div-overflow.stderr b/src/tools/miri/tests/fail/intrinsics/simd-div-overflow.stderr
index 27d4dd9e3e7..85058b008ee 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-div-overflow.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-div-overflow.stderr
@@ -11,5 +11,5 @@ LL |         simd_div(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr b/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr
index 7b2387944af..d4d1830e963 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr
@@ -11,5 +11,5 @@ LL |         let _x: i32x2 = f32x2::from_array([f32::MAX, f32::MIN]).to_int_unch
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-gather.stderr b/src/tools/miri/tests/fail/intrinsics/simd-gather.stderr
index f3bd275b027..d111644eec8 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-gather.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-gather.stderr
@@ -11,5 +11,5 @@ LL |         let _result = Simd::gather_select_unchecked(&vec, Mask::splat(true)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-reduce-invalid-bool.stderr b/src/tools/miri/tests/fail/intrinsics/simd-reduce-invalid-bool.stderr
index 1e5ac5277e6..b6c43d34b9d 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-reduce-invalid-bool.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-reduce-invalid-bool.stderr
@@ -11,5 +11,5 @@ LL |         simd_reduce_any(x);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-rem-by-zero.stderr b/src/tools/miri/tests/fail/intrinsics/simd-rem-by-zero.stderr
index 96248e7e599..d29d22d8aef 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-rem-by-zero.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-rem-by-zero.stderr
@@ -11,5 +11,5 @@ LL |         simd_rem(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-scatter.stderr b/src/tools/miri/tests/fail/intrinsics/simd-scatter.stderr
index 1720a24aa13..8b517b6e972 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-scatter.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-scatter.stderr
@@ -22,5 +22,5 @@ LL |         let mut vec: Vec<i8> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-select-bitmask-invalid.stderr b/src/tools/miri/tests/fail/intrinsics/simd-select-bitmask-invalid.stderr
index e72cce998d0..1f978e13bb9 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-select-bitmask-invalid.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-select-bitmask-invalid.stderr
@@ -11,5 +11,5 @@ LL |         simd_select_bitmask(0b11111111u8, x, x);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-select-invalid-bool.stderr b/src/tools/miri/tests/fail/intrinsics/simd-select-invalid-bool.stderr
index 277ceb54ec7..e0c05474831 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-select-invalid-bool.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-select-invalid-bool.stderr
@@ -11,5 +11,5 @@ LL |         simd_select(x, x, x);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr b/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr
index c8445bb3cdc..3a4ec008b44 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr
@@ -11,5 +11,5 @@ LL |         simd_shl(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr b/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr
index 8eec30c5a52..07636b8c0bb 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr
@@ -11,5 +11,5 @@ LL |         simd_shr(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr
index f5e96198ee4..922de4226fa 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { 40000u16.unchecked_add(30000) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr
index 5a5c7070ae0..05456eaf195 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { (-30000i16).unchecked_add(-8000) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_div1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_div1.stderr
index 9267e0c4947..9dc4bcaee2f 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_div1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_div1.stderr
@@ -11,5 +11,5 @@ LL |         std::intrinsics::unchecked_div(i16::MIN, -1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr
index 9a5a585e1cc..533beaa65ff 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { 300u16.unchecked_mul(250u16) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr
index 46b9f618217..4c6bae6f0bf 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { 1_000_000_000i32.unchecked_mul(-4) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_shl.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_shl.stderr
index 264e9baf053..f30cf4479e6 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_shl.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_shl.stderr
@@ -11,5 +11,5 @@ LL |         let _n = 1i8.unchecked_shl(8);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_shl2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_shl2.stderr
index ab27c9fe911..a572f34b92c 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_shl2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_shl2.stderr
@@ -11,5 +11,5 @@ LL |         let _n = intrinsics::unchecked_shl(1i8, -1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_shr.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_shr.stderr
index 378ff9734c1..22e0b1a0d9e 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_shr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_shr.stderr
@@ -11,5 +11,5 @@ LL |         let _n = 1i64.unchecked_shr(64);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr
index 01e569767ba..72187e20e23 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { 14u32.unchecked_sub(22) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr
index 38c1647b4f4..ec28384f633 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { 30000i16.unchecked_sub(-7000) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
index c63cfe06553..2196673c39a 100644
--- a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
@@ -22,5 +22,5 @@ LL |     let _ = unsafe { std::mem::uninitialized::<!>() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr b/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr
index b2969ca3b59..def180935cc 100644
--- a/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { write_bytes::<u8>(std::ptr::null_mut(), 0, 0) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/write_bytes_overflow.stderr b/src/tools/miri/tests/fail/intrinsics/write_bytes_overflow.stderr
index f88afde879a..326c180fadb 100644
--- a/src/tools/miri/tests/fail/intrinsics/write_bytes_overflow.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/write_bytes_overflow.stderr
@@ -11,5 +11,5 @@ LL |         (&mut y as *mut i32).write_bytes(0u8, 1usize << (mem::size_of::<usi
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
index f954c4e9712..90ba5995cee 100644
--- a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
@@ -22,5 +22,5 @@ LL |     let _ = unsafe { std::mem::zeroed::<fn()>() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/invalid_bool.stderr b/src/tools/miri/tests/fail/invalid_bool.stderr
index a522f6cd4ff..fd1ea5087b2 100644
--- a/src/tools/miri/tests/fail/invalid_bool.stderr
+++ b/src/tools/miri/tests/fail/invalid_bool.stderr
@@ -11,5 +11,5 @@ LL |     let _x = b == std::hint::black_box(true);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/invalid_char.stderr b/src/tools/miri/tests/fail/invalid_char.stderr
index d49d753d9e1..81d6cdad157 100644
--- a/src/tools/miri/tests/fail/invalid_char.stderr
+++ b/src/tools/miri/tests/fail/invalid_char.stderr
@@ -11,5 +11,5 @@ LL |     let _x = c == 'x';
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/invalid_enum_tag.stderr b/src/tools/miri/tests/fail/invalid_enum_tag.stderr
index 01d931de919..5a446bb2a56 100644
--- a/src/tools/miri/tests/fail/invalid_enum_tag.stderr
+++ b/src/tools/miri/tests/fail/invalid_enum_tag.stderr
@@ -11,5 +11,5 @@ LL |     let _val = mem::discriminant(&f);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/invalid_int.stderr b/src/tools/miri/tests/fail/invalid_int.stderr
index eccdbff6045..a450b939384 100644
--- a/src/tools/miri/tests/fail/invalid_int.stderr
+++ b/src/tools/miri/tests/fail/invalid_int.stderr
@@ -11,5 +11,5 @@ LL |     let i = unsafe { std::mem::MaybeUninit::<i32>::uninit().assume_init() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/issue-miri-1112.stderr b/src/tools/miri/tests/fail/issue-miri-1112.stderr
index f1cb50ab9be..7ac65c152e9 100644
--- a/src/tools/miri/tests/fail/issue-miri-1112.stderr
+++ b/src/tools/miri/tests/fail/issue-miri-1112.stderr
@@ -16,5 +16,5 @@ LL |         let _raw: &FunnyPointer = FunnyPointer::from_data_ptr(&hello, &meta
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/issue-miri-2432.stderr b/src/tools/miri/tests/fail/issue-miri-2432.stderr
index b8e13b61ceb..3befe31dc5a 100644
--- a/src/tools/miri/tests/fail/issue-miri-2432.stderr
+++ b/src/tools/miri/tests/fail/issue-miri-2432.stderr
@@ -11,5 +11,5 @@ LL |     <dyn X as X>::foo(&());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/memleak.stderr b/src/tools/miri/tests/fail/memleak.stderr
index 12bb944b076..9c885c37f3a 100644
--- a/src/tools/miri/tests/fail/memleak.stderr
+++ b/src/tools/miri/tests/fail/memleak.stderr
@@ -19,5 +19,5 @@ note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a
 
 note: the evaluated program leaked memory, pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/memleak_no_backtrace.stderr b/src/tools/miri/tests/fail/memleak_no_backtrace.stderr
index f44e6ce0797..22e8c558061 100644
--- a/src/tools/miri/tests/fail/memleak_no_backtrace.stderr
+++ b/src/tools/miri/tests/fail/memleak_no_backtrace.stderr
@@ -1,4 +1,4 @@
 error: the evaluated program leaked memory, pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/memleak_rc.64bit.stderr b/src/tools/miri/tests/fail/memleak_rc.64bit.stderr
index ec5f5f5bed3..b68991602ea 100644
--- a/src/tools/miri/tests/fail/memleak_rc.64bit.stderr
+++ b/src/tools/miri/tests/fail/memleak_rc.64bit.stderr
@@ -20,5 +20,5 @@ note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a
 
 note: the evaluated program leaked memory, pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/modifying_constants.stderr b/src/tools/miri/tests/fail/modifying_constants.stderr
index 6425a5d7a0a..c1eca7866ad 100644
--- a/src/tools/miri/tests/fail/modifying_constants.stderr
+++ b/src/tools/miri/tests/fail/modifying_constants.stderr
@@ -11,5 +11,5 @@ LL |     *y = 42;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/never_match_never.stderr b/src/tools/miri/tests/fail/never_match_never.stderr
index 33dab81d5b0..751894f1985 100644
--- a/src/tools/miri/tests/fail/never_match_never.stderr
+++ b/src/tools/miri/tests/fail/never_match_never.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { match (*ptr).1 {} }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/never_say_never.stderr b/src/tools/miri/tests/fail/never_say_never.stderr
index 9d3a8df525a..1720cc893ab 100644
--- a/src/tools/miri/tests/fail/never_say_never.stderr
+++ b/src/tools/miri/tests/fail/never_say_never.stderr
@@ -11,5 +11,5 @@ LL |     f(x)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/never_transmute_humans.stderr b/src/tools/miri/tests/fail/never_transmute_humans.stderr
index a51ca7fe7e7..6916c935995 100644
--- a/src/tools/miri/tests/fail/never_transmute_humans.stderr
+++ b/src/tools/miri/tests/fail/never_transmute_humans.stderr
@@ -11,5 +11,5 @@ LL |         std::mem::transmute::<Human, !>(Human)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/never_transmute_void.stderr b/src/tools/miri/tests/fail/never_transmute_void.stderr
index 413172b2546..4ca306373a1 100644
--- a/src/tools/miri/tests/fail/never_transmute_void.stderr
+++ b/src/tools/miri/tests/fail/never_transmute_void.stderr
@@ -16,5 +16,5 @@ LL |     m::f(v);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/no_main.stderr b/src/tools/miri/tests/fail/no_main.stderr
index 88bdfb4e387..1c4fc88989b 100644
--- a/src/tools/miri/tests/fail/no_main.stderr
+++ b/src/tools/miri/tests/fail/no_main.stderr
@@ -1,4 +1,4 @@
 error: miri can only run programs that have a main function
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/overlapping_assignment.stderr b/src/tools/miri/tests/fail/overlapping_assignment.stderr
index 42a000dfcc6..54e104e3513 100644
--- a/src/tools/miri/tests/fail/overlapping_assignment.stderr
+++ b/src/tools/miri/tests/fail/overlapping_assignment.stderr
@@ -16,5 +16,5 @@ LL |     self_copy(ptr, ptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/bad_miri_start_panic.stderr b/src/tools/miri/tests/fail/panic/bad_miri_start_panic.stderr
index 4e5a2dfba34..2d96ae4b7de 100644
--- a/src/tools/miri/tests/fail/panic/bad_miri_start_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/bad_miri_start_panic.stderr
@@ -13,5 +13,5 @@ LL |     unsafe { miri_start_panic(&mut 0) }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/bad_unwind.stderr b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
index c2d007e5729..e4af01feb8d 100644
--- a/src/tools/miri/tests/fail/panic/bad_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
@@ -22,5 +22,5 @@ LL |     std::panic::catch_unwind(|| unwind()).unwrap_err();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/double_panic.stderr b/src/tools/miri/tests/fail/panic/double_panic.stderr
index 5de7b3cf929..75ca0901bc8 100644
--- a/src/tools/miri/tests/fail/panic/double_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/double_panic.stderr
@@ -31,5 +31,5 @@ LL | | }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/no_std.stderr b/src/tools/miri/tests/fail/panic/no_std.stderr
index 47ec710052a..8b48f752967 100644
--- a/src/tools/miri/tests/fail/panic/no_std.stderr
+++ b/src/tools/miri/tests/fail/panic/no_std.stderr
@@ -16,5 +16,5 @@ LL |     panic!("blarg I am dead")
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort1.stderr b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
index 6bd7157031a..690f5bbec13 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort1.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
@@ -23,5 +23,5 @@ LL |     std::panic!("panicking from libstd");
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort2.stderr b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
index 1d828d2e0f5..e937fa02b0d 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort2.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
@@ -23,5 +23,5 @@ LL |     std::panic!("{}-panicking from libstd", 42);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort3.stderr b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
index 5e43444572e..0513ae7e765 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort3.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
@@ -23,5 +23,5 @@ LL |     core::panic!("panicking from libcore");
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort4.stderr b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
index 12c4b857134..314e0c30792 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort4.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
@@ -23,5 +23,5 @@ LL |     core::panic!("{}-panicking from libcore", 42);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr b/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
index 17e92fec6fd..778061490f0 100644
--- a/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
@@ -3,5 +3,5 @@ ow
 fatal runtime error: thread local panicked on drop
 error: abnormal termination: the program aborted execution
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr b/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
index b1a384bbb52..367e2ee1f0b 100644
--- a/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
@@ -3,5 +3,5 @@ ow
 fatal runtime error: thread local panicked on drop
 error: abnormal termination: the program aborted execution
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/panic/unwind_panic_abort.stderr b/src/tools/miri/tests/fail/panic/unwind_panic_abort.stderr
index 363e69ba41d..4739c7f2ac6 100644
--- a/src/tools/miri/tests/fail/panic/unwind_panic_abort.stderr
+++ b/src/tools/miri/tests/fail/panic/unwind_panic_abort.stderr
@@ -11,5 +11,5 @@ LL |         miri_start_panic(&mut 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/provenance/pointer_partial_overwrite.stderr b/src/tools/miri/tests/fail/provenance/pointer_partial_overwrite.stderr
index 8fafc7e82c9..50bff22f766 100644
--- a/src/tools/miri/tests/fail/provenance/pointer_partial_overwrite.stderr
+++ b/src/tools/miri/tests/fail/provenance/pointer_partial_overwrite.stderr
@@ -11,5 +11,5 @@ LL |     let x = *p;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/provenance/provenance_transmute.stderr b/src/tools/miri/tests/fail/provenance/provenance_transmute.stderr
index 319517d062b..6b1c2941c07 100644
--- a/src/tools/miri/tests/fail/provenance/provenance_transmute.stderr
+++ b/src/tools/miri/tests/fail/provenance/provenance_transmute.stderr
@@ -16,5 +16,5 @@ LL |         deref(ptr1, ptr2.with_addr(ptr1.addr()));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/provenance/ptr_int_unexposed.stderr b/src/tools/miri/tests/fail/provenance/ptr_int_unexposed.stderr
index 9ebabfb129c..92ccec50274 100644
--- a/src/tools/miri/tests/fail/provenance/ptr_int_unexposed.stderr
+++ b/src/tools/miri/tests/fail/provenance/ptr_int_unexposed.stderr
@@ -11,5 +11,5 @@ LL |     assert_eq!(unsafe { *ptr }, 3);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/provenance/ptr_invalid.stderr b/src/tools/miri/tests/fail/provenance/ptr_invalid.stderr
index 50ceae7cfda..8b8033b0d1d 100644
--- a/src/tools/miri/tests/fail/provenance/ptr_invalid.stderr
+++ b/src/tools/miri/tests/fail/provenance/ptr_invalid.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { *xptr_invalid };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/provenance/ptr_invalid_offset.stderr b/src/tools/miri/tests/fail/provenance/ptr_invalid_offset.stderr
index 3607635c8fb..8ae140ee004 100644
--- a/src/tools/miri/tests/fail/provenance/ptr_invalid_offset.stderr
+++ b/src/tools/miri/tests/fail/provenance/ptr_invalid_offset.stderr
@@ -11,5 +11,5 @@ LL |     let _ = unsafe { roundtrip.offset(1) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/provenance/strict_provenance_cast.stderr b/src/tools/miri/tests/fail/provenance/strict_provenance_cast.stderr
index 998ccc8bb49..a110ed4ebb2 100644
--- a/src/tools/miri/tests/fail/provenance/strict_provenance_cast.stderr
+++ b/src/tools/miri/tests/fail/provenance/strict_provenance_cast.stderr
@@ -10,5 +10,5 @@ LL |     let _ptr = std::ptr::from_exposed_addr::<i32>(addr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/rc_as_ptr.stderr b/src/tools/miri/tests/fail/rc_as_ptr.stderr
index eb522b2bc0c..83d85f8adff 100644
--- a/src/tools/miri/tests/fail/rc_as_ptr.stderr
+++ b/src/tools/miri/tests/fail/rc_as_ptr.stderr
@@ -22,5 +22,5 @@ LL |     drop(strong);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/reading_half_a_pointer.stderr b/src/tools/miri/tests/fail/reading_half_a_pointer.stderr
index df4adb5ead7..03f93510d09 100644
--- a/src/tools/miri/tests/fail/reading_half_a_pointer.stderr
+++ b/src/tools/miri/tests/fail/reading_half_a_pointer.stderr
@@ -11,5 +11,5 @@ LL |         let _val = *x;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/rustc-error.stderr b/src/tools/miri/tests/fail/rustc-error.stderr
index 09d0f7a6df9..3f911c172d4 100644
--- a/src/tools/miri/tests/fail/rustc-error.stderr
+++ b/src/tools/miri/tests/fail/rustc-error.stderr
@@ -9,6 +9,6 @@ help: use `!` to invoke the macro
 LL |     println!("Hello, world!");
    |            +
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-decl.stderr b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-decl.stderr
index 200f5f56213..159a02f2c03 100644
--- a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-decl.stderr
+++ b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-decl.stderr
@@ -11,5 +11,5 @@ LL | ...   miri_resolve_frame(*frame, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-flags.stderr b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-flags.stderr
index 5d51790f8a5..2523e5063e1 100644
--- a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-flags.stderr
+++ b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-flags.stderr
@@ -10,5 +10,5 @@ LL |         miri_get_backtrace(2, std::ptr::null_mut());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-ptr.stderr b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-ptr.stderr
index f23f834000a..04dbd657d20 100644
--- a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-ptr.stderr
+++ b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-ptr.stderr
@@ -11,5 +11,5 @@ LL |         miri_resolve_frame(std::ptr::null_mut(), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-flags.stderr b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-flags.stderr
index fe123c2352f..36446ae283b 100644
--- a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-flags.stderr
+++ b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-flags.stderr
@@ -10,5 +10,5 @@ LL |         miri_resolve_frame(buf[0], 2);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-names-flags.stderr b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-names-flags.stderr
index a3003c9093f..ff60ab09172 100644
--- a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-names-flags.stderr
+++ b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-resolve-names-flags.stderr
@@ -10,5 +10,5 @@ LL | ...   miri_resolve_frame_names(buf[0], 2, std::ptr::null_mut(), std::ptr::n
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-size-flags.stderr b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-size-flags.stderr
index b4a02c0e363..6d4c370050f 100644
--- a/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-size-flags.stderr
+++ b/src/tools/miri/tests/fail/shims/backtrace/bad-backtrace-size-flags.stderr
@@ -10,5 +10,5 @@ LL |         miri_backtrace_size(2);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr b/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
index a1b9662961d..e1b18000866 100644
--- a/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
+++ b/src/tools/miri/tests/fail/shims/fs/isolated_file.stderr
@@ -25,5 +25,5 @@ LL |     let _file = std::fs::File::open("file.txt").unwrap();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/shims/shim_arg_size.stderr b/src/tools/miri/tests/fail/shims/shim_arg_size.stderr
index d951f81810e..b40d02ac345 100644
--- a/src/tools/miri/tests/fail/shims/shim_arg_size.stderr
+++ b/src/tools/miri/tests/fail/shims/shim_arg_size.stderr
@@ -11,5 +11,5 @@ LL |         memchr(std::ptr::null(), 0, 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.stderr b/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.stderr
index 325565fa1e7..966279723c4 100644
--- a/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.stderr
+++ b/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.stderr
@@ -16,5 +16,5 @@ LL |         test_cpp20_rwc_syncs();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/deallocate_against_protector1.stderr b/src/tools/miri/tests/fail/stacked_borrows/deallocate_against_protector1.stderr
index 00ea6b27d4c..2cc714f935a 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/deallocate_against_protector1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/deallocate_against_protector1.stderr
@@ -34,5 +34,5 @@ LL | |     });
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/disable_mut_does_not_merge_srw.stderr b/src/tools/miri/tests/fail/stacked_borrows/disable_mut_does_not_merge_srw.stderr
index bd79b401f66..aa26a003f22 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/disable_mut_does_not_merge_srw.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/disable_mut_does_not_merge_srw.stderr
@@ -24,5 +24,5 @@ LL |         *base = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_protector.stderr b/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_protector.stderr
index 3d0cef241c3..627c790f843 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_protector.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_protector.stderr
@@ -29,5 +29,5 @@ LL |         core::ptr::drop_in_place(x);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_retag.stderr b/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_retag.stderr
index 7f2917e7950..6b8465804a5 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_retag.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/drop_in_place_retag.stderr
@@ -25,5 +25,5 @@ LL |         core::ptr::drop_in_place(x.cast_mut());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/exposed_only_ro.stderr b/src/tools/miri/tests/fail/stacked_borrows/exposed_only_ro.stderr
index cb5e7bffde4..201bdcdeb97 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/exposed_only_ro.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/exposed_only_ro.stderr
@@ -14,5 +14,5 @@ LL |     unsafe { *ptr = 0 };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation.stderr b/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation.stderr
index 236c8fb0187..2a841aa0a8d 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation.stderr
@@ -24,5 +24,5 @@ LL |     x.do_bad();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation2.stderr b/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation2.stderr
index 45c2197050a..42f042bfad2 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation2.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/fnentry_invalidation2.stderr
@@ -24,5 +24,5 @@ LL |     let _ = t.sli.as_mut_ptr();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.stderr
index 7fff60f25fb..7a44c8384a0 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.stderr
@@ -26,5 +26,5 @@ LL |         dealloc(ptr2, Layout::from_size_align_unchecked(1, 1));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read1.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read1.stderr
index 7a159c9d3fe..2dfb660c53c 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read1.stderr
@@ -24,5 +24,5 @@ LL |     let _val = unsafe { *xraw };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read2.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read2.stderr
index e3e79f6f0f0..ce3b920c1dc 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read2.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read2.stderr
@@ -24,5 +24,5 @@ LL |     let shr = unsafe { &*xraw };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read3.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read3.stderr
index 3a8687ad9aa..2c81fda1411 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read3.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read3.stderr
@@ -24,5 +24,5 @@ LL |     let _val = unsafe { *xref1.r };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read4.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read4.stderr
index dcf37b26901..98bfd56cd3c 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read4.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read4.stderr
@@ -24,5 +24,5 @@ LL |     let _val = unsafe { *xraw }; // use the raw again, this invalidates xre
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read5.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read5.stderr
index 1793798d15f..e3b18e7d4f8 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read5.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read5.stderr
@@ -24,5 +24,5 @@ LL |     mem::forget(unsafe { ptr::read(xshr) }); // but after reading through t
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read6.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read6.stderr
index 17b28dee3c7..415a85bd68c 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read6.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read6.stderr
@@ -24,5 +24,5 @@ LL |         let x = &mut *x; // kill `raw`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read7.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read7.stderr
index 1a9d551431c..248ae62d5eb 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read7.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read7.stderr
@@ -24,5 +24,5 @@ LL |         let _val = ptr::read(raw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read8.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read8.stderr
index b43079c3b7f..fd5ed383f1a 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read8.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read8.stderr
@@ -24,5 +24,5 @@ LL |         *y2 += 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed1.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed1.stderr
index fbd5d8b956d..33fcd11ff7a 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed1.stderr
@@ -24,5 +24,5 @@ LL |         *exposed_ptr = 0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed2.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed2.stderr
index 19e4cbdb938..a948c5df166 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed2.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_read_despite_exposed2.stderr
@@ -24,5 +24,5 @@ LL |         let _val = *exposed_ptr;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_write2.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_write2.stderr
index 3e11e86eb81..65b4fc5f3fa 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_write2.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_write2.stderr
@@ -24,5 +24,5 @@ LL |     drop(&mut *target); // reborrow
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_write3.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_write3.stderr
index 4053325821e..08d9f33a169 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_write3.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_write3.stderr
@@ -19,5 +19,5 @@ LL |     let ptr = r#ref as *const _ as *mut _; // raw ptr, with raw tag
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_write4.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_write4.stderr
index fceda8db4ce..4ee5ec38539 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_write4.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_write4.stderr
@@ -24,5 +24,5 @@ LL |     let _mut_ref: &mut i32 = unsafe { mem::transmute(raw) }; // &mut, with
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_write_despite_exposed1.stderr b/src/tools/miri/tests/fail/stacked_borrows/illegal_write_despite_exposed1.stderr
index 1bb3afe483e..70e9038bab3 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_write_despite_exposed1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_write_despite_exposed1.stderr
@@ -24,5 +24,5 @@ LL |         *exposed_ptr = 0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/interior_mut1.stderr b/src/tools/miri/tests/fail/stacked_borrows/interior_mut1.stderr
index ba8977c5674..f8bc1667ddb 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/interior_mut1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/interior_mut1.stderr
@@ -24,5 +24,5 @@ LL |         *c.get() = UnsafeCell::new(1); // invalidates inner_shr
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/interior_mut2.stderr b/src/tools/miri/tests/fail/stacked_borrows/interior_mut2.stderr
index 97ebe72bf29..a69fc6ff8ba 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/interior_mut2.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/interior_mut2.stderr
@@ -24,5 +24,5 @@ LL |         *c.get() = UnsafeCell::new(0); // now inner_shr gets invalidated
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/invalidate_against_protector1.stderr b/src/tools/miri/tests/fail/stacked_borrows/invalidate_against_protector1.stderr
index 95fa4c51d12..22a0b42cfd8 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/invalidate_against_protector1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/invalidate_against_protector1.stderr
@@ -26,5 +26,5 @@ LL |     inner(xraw, xref);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/load_invalid_mut.stderr b/src/tools/miri/tests/fail/stacked_borrows/load_invalid_mut.stderr
index 7aca065ca0d..9d707c3f85d 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/load_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/load_invalid_mut.stderr
@@ -24,5 +24,5 @@ LL |     let _val = unsafe { *xraw }; // invalidate xref
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/pass_invalid_mut.stderr b/src/tools/miri/tests/fail/stacked_borrows/pass_invalid_mut.stderr
index 96cec327b9d..0a017e18264 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/pass_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/pass_invalid_mut.stderr
@@ -24,5 +24,5 @@ LL |     let _val = unsafe { *xraw }; // invalidate xref
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/pointer_smuggling.stderr b/src/tools/miri/tests/fail/stacked_borrows/pointer_smuggling.stderr
index e20b5b89a2f..1fddcaf3dad 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/pointer_smuggling.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/pointer_smuggling.stderr
@@ -29,5 +29,5 @@ LL |     fun2(); // if they now use a raw ptr they break our reference
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/raw_tracking.stderr b/src/tools/miri/tests/fail/stacked_borrows/raw_tracking.stderr
index 9f7e7a058df..0d07d154ba5 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/raw_tracking.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/raw_tracking.stderr
@@ -24,5 +24,5 @@ LL |     let raw2 = &mut l as *mut _; // invalidates raw1
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_protected_read.stderr b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_protected_read.stderr
index ce77976f88b..905776155eb 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_protected_read.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_protected_read.stderr
@@ -16,5 +16,5 @@ LL |     unsafe { ptr.0.read() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr
index 1496c353e52..129b9ffb26e 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr
@@ -21,5 +21,5 @@ LL |     let t2 = std::thread::spawn(move || thread_2(p));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut.stderr b/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut.stderr
index 2bf91b676c4..78008e92642 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut.stderr
@@ -29,5 +29,5 @@ LL |     foo(&mut (1, 2));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_option.stderr b/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_option.stderr
index d357ab9639b..b9ae34df077 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_option.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_option.stderr
@@ -30,5 +30,5 @@ LL |     match foo(&mut (1, 2)) {
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_tuple.stderr b/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_tuple.stderr
index d346e6fa895..7522115c516 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_tuple.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/return_invalid_mut_tuple.stderr
@@ -30,5 +30,5 @@ LL |     foo(&mut (1, 2)).0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak1.stderr b/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak1.stderr
index 10f97180b75..b5106c9d940 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak1.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak1.stderr
@@ -24,5 +24,5 @@ LL |         shr_rw.set(1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak2.stderr b/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak2.stderr
index 0e37c4ffb39..ccea83db857 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak2.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/shared_rw_borrows_are_weak2.stderr
@@ -24,5 +24,5 @@ LL |         shr_rw.replace(1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/static_memory_modification.stderr b/src/tools/miri/tests/fail/stacked_borrows/static_memory_modification.stderr
index ca99a8262b8..f605fa9d3b9 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/static_memory_modification.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/static_memory_modification.stderr
@@ -11,5 +11,5 @@ LL |         std::mem::transmute::<&usize, &mut usize>(&X)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/track_caller.stderr b/src/tools/miri/tests/fail/stacked_borrows/track_caller.stderr
index 05be0d3f1e9..f341222a664 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/track_caller.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/track_caller.stderr
@@ -24,5 +24,5 @@ LL |     callee(xraw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.stderr b/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.stderr
index ac962311d42..7d8132b85c8 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/transmute-is-no-escape.stderr
@@ -19,5 +19,5 @@ LL |     let raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/unescaped_local.stderr b/src/tools/miri/tests/fail/stacked_borrows/unescaped_local.stderr
index 4deafa89000..50c02b3455e 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/unescaped_local.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/unescaped_local.stderr
@@ -14,5 +14,5 @@ LL |         *raw = 13;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/unescaped_static.stderr b/src/tools/miri/tests/fail/stacked_borrows/unescaped_static.stderr
index 7a40d1078b3..7578b89708a 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/unescaped_static.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/unescaped_static.stderr
@@ -19,5 +19,5 @@ LL |     let ptr_to_first = &ARRAY[0] as *const u8;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/zst_slice.stderr b/src/tools/miri/tests/fail/stacked_borrows/zst_slice.stderr
index 950abc4cbcf..5568051905c 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/zst_slice.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/zst_slice.stderr
@@ -24,5 +24,5 @@ LL |         assert_eq!(*s.get_unchecked(1), 2);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/static_memory_modification1.stderr b/src/tools/miri/tests/fail/static_memory_modification1.stderr
index 5e7213ee608..877cf1d6e47 100644
--- a/src/tools/miri/tests/fail/static_memory_modification1.stderr
+++ b/src/tools/miri/tests/fail/static_memory_modification1.stderr
@@ -11,5 +11,5 @@ LL |         *std::mem::transmute::<&usize, &mut usize>(&X) = 6;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/static_memory_modification2.stderr b/src/tools/miri/tests/fail/static_memory_modification2.stderr
index 4c160cd3206..77bbace4696 100644
--- a/src/tools/miri/tests/fail/static_memory_modification2.stderr
+++ b/src/tools/miri/tests/fail/static_memory_modification2.stderr
@@ -11,5 +11,5 @@ LL |         transmute::<&[u8], &mut [u8]>(s.as_bytes())[4] = 42;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/static_memory_modification3.stderr b/src/tools/miri/tests/fail/static_memory_modification3.stderr
index 1986059c50a..a04609805cb 100644
--- a/src/tools/miri/tests/fail/static_memory_modification3.stderr
+++ b/src/tools/miri/tests/fail/static_memory_modification3.stderr
@@ -11,5 +11,5 @@ LL |         transmute::<&[u8], &mut [u8]>(bs)[4] = 42;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/terminate-terminator.stderr b/src/tools/miri/tests/fail/terminate-terminator.stderr
index dc634df831f..be66bad6fc3 100644
--- a/src/tools/miri/tests/fail/terminate-terminator.stderr
+++ b/src/tools/miri/tests/fail/terminate-terminator.stderr
@@ -41,5 +41,5 @@ LL |     panic_abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/src/tools/miri/tests/fail/tls/tls_static_dealloc.stderr b/src/tools/miri/tests/fail/tls/tls_static_dealloc.stderr
index ae8a421ca40..a49933b7d05 100644
--- a/src/tools/miri/tests/fail/tls/tls_static_dealloc.stderr
+++ b/src/tools/miri/tests/fail/tls/tls_static_dealloc.stderr
@@ -11,5 +11,5 @@ LL |         let _val = *dangling_ptr.0;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tls_macro_leak.stderr b/src/tools/miri/tests/fail/tls_macro_leak.stderr
index e9daa78543c..be0e846b633 100644
--- a/src/tools/miri/tests/fail/tls_macro_leak.stderr
+++ b/src/tools/miri/tests/fail/tls_macro_leak.stderr
@@ -28,5 +28,5 @@ note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a
 
 note: the evaluated program leaked memory, pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tls_static_leak.stderr b/src/tools/miri/tests/fail/tls_static_leak.stderr
index bcfaf80229a..533651f2efd 100644
--- a/src/tools/miri/tests/fail/tls_static_leak.stderr
+++ b/src/tools/miri/tests/fail/tls_static_leak.stderr
@@ -19,5 +19,5 @@ note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a
 
 note: the evaluated program leaked memory, pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/transmute-pair-uninit.stderr b/src/tools/miri/tests/fail/transmute-pair-uninit.stderr
index 642bf0a7134..30306054fbb 100644
--- a/src/tools/miri/tests/fail/transmute-pair-uninit.stderr
+++ b/src/tools/miri/tests/fail/transmute-pair-uninit.stderr
@@ -11,5 +11,5 @@ LL |     let v = unsafe { *z.offset(first_undef) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr b/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr
index fcbc2e12786..58d22c5641f 100644
--- a/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr
@@ -34,5 +34,5 @@ LL |     let _val = *x;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/children-can-alias.default.stderr b/src/tools/miri/tests/fail/tree_borrows/children-can-alias.default.stderr
index 1b05be9c54d..87286f1a1a6 100644
--- a/src/tools/miri/tests/fail/tree_borrows/children-can-alias.default.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/children-can-alias.default.stderr
@@ -11,5 +11,5 @@ LL |         std::hint::unreachable_unchecked();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/children-can-alias.uniq.stderr b/src/tools/miri/tests/fail/tree_borrows/children-can-alias.uniq.stderr
index 2f77b27729e..be85e1a1cee 100644
--- a/src/tools/miri/tests/fail/tree_borrows/children-can-alias.uniq.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/children-can-alias.uniq.stderr
@@ -33,5 +33,5 @@ LL |         raw_children_of_unique_can_alias(Unique::new_unchecked(raw));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/error-range.stderr b/src/tools/miri/tests/fail/tree_borrows/error-range.stderr
index b58dcd7572b..a03869f33bb 100644
--- a/src/tools/miri/tests/fail/tree_borrows/error-range.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/error-range.stderr
@@ -28,5 +28,5 @@ LL |         data[5] = 1;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr b/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr
index 0f1e7735a0e..7df6cd9d923 100644
--- a/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr
@@ -28,5 +28,5 @@ LL |     x.do_bad();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/outside-range.stderr b/src/tools/miri/tests/fail/tree_borrows/outside-range.stderr
index 8b3bf8414db..5644862d23e 100644
--- a/src/tools/miri/tests/fail/tree_borrows/outside-range.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/outside-range.stderr
@@ -28,5 +28,5 @@ LL |         stuff(&mut *raw, raw);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr b/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr
index addba9d809e..a9d5b0a68c1 100644
--- a/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr
@@ -29,5 +29,5 @@ LL |         assert_eq!(root, 0); // Parent Read
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr b/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr
index 056ac6db550..32cf1c18cde 100644
--- a/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr
@@ -39,5 +39,5 @@ LL |     foo(xref);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/reserved/cell-protected-write.stderr b/src/tools/miri/tests/fail/tree_borrows/reserved/cell-protected-write.stderr
index fc92770ed16..ba6c30cf935 100644
--- a/src/tools/miri/tests/fail/tree_borrows/reserved/cell-protected-write.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/reserved/cell-protected-write.stderr
@@ -38,5 +38,5 @@ LL |         write_second(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/reserved/int-protected-write.stderr b/src/tools/miri/tests/fail/tree_borrows/reserved/int-protected-write.stderr
index 4b4b8f24a68..16081871d94 100644
--- a/src/tools/miri/tests/fail/tree_borrows/reserved/int-protected-write.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/reserved/int-protected-write.stderr
@@ -38,5 +38,5 @@ LL |         write_second(x, y);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr b/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr
index 978e5a340fa..dff2374ba9f 100644
--- a/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr
@@ -34,5 +34,5 @@ LL |     let _val = unsafe { *xraw }; // invalidate xref for writing
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/spurious_read.stderr b/src/tools/miri/tests/fail/tree_borrows/spurious_read.stderr
index 99ffb849339..e48145567f5 100644
--- a/src/tools/miri/tests/fail/tree_borrows/spurious_read.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/spurious_read.stderr
@@ -40,5 +40,5 @@ LL |         let _y = as_mut(unsafe { &mut *ptr.0 }, b.clone());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/strongly-protected.stderr b/src/tools/miri/tests/fail/tree_borrows/strongly-protected.stderr
index fb2e77f9d2a..4793c287045 100644
--- a/src/tools/miri/tests/fail/tree_borrows/strongly-protected.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/strongly-protected.stderr
@@ -45,5 +45,5 @@ LL | |     });
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr b/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr
index eb4d5c10c25..f058c61ec3b 100644
--- a/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr
@@ -28,5 +28,5 @@ LL |         let _definitely_parent = data; // definitely Frozen by now
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/unique.uniq.stderr b/src/tools/miri/tests/fail/tree_borrows/unique.uniq.stderr
index 2d8936f273f..ba53a87f84a 100644
--- a/src/tools/miri/tests/fail/tree_borrows/unique.uniq.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/unique.uniq.stderr
@@ -34,5 +34,5 @@ LL |         let _maybe_parent = *rawptr; // maybe becomes Frozen
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/write-during-2phase.stderr b/src/tools/miri/tests/fail/tree_borrows/write-during-2phase.stderr
index 3a82d028704..35087b11468 100644
--- a/src/tools/miri/tests/fail/tree_borrows/write-during-2phase.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/write-during-2phase.stderr
@@ -34,5 +34,5 @@ LL | |     });
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/type-too-large.stderr b/src/tools/miri/tests/fail/type-too-large.stderr
index cb1d725ec87..cdff049198d 100644
--- a/src/tools/miri/tests/fail/type-too-large.stderr
+++ b/src/tools/miri/tests/fail/type-too-large.stderr
@@ -8,5 +8,5 @@ LL |     _fat = [0; (1u64 << 61) as usize + (1u64 << 31) as usize];
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/alignment.stderr b/src/tools/miri/tests/fail/unaligned_pointers/alignment.stderr
index 5fdec1dc74c..ca3d34661d3 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/alignment.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/alignment.stderr
@@ -11,5 +11,5 @@ LL |         *(x_ptr as *mut u32) = 42; *(x_ptr.add(1) as *mut u32) = 42;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/atomic_unaligned.stderr b/src/tools/miri/tests/fail/unaligned_pointers/atomic_unaligned.stderr
index 8c3aa3429af..161e8977bf4 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/atomic_unaligned.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/atomic_unaligned.stderr
@@ -11,5 +11,5 @@ LL |         ::std::intrinsics::atomic_load_seqcst(zptr);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr b/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr
index db35a20ee22..600028337fa 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/drop_in_place.stderr
@@ -16,5 +16,5 @@ LL |         core::ptr::drop_in_place(p);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr b/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr
index cfb43ae891f..05e30f833bb 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/dyn_alignment.stderr
@@ -11,5 +11,5 @@ LL |         let _ptr = &*ptr;
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment.stderr b/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment.stderr
index 2ffbc2a434e..9046502975d 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment.stderr
@@ -16,5 +16,5 @@ LL |         foo(odd_ptr.cast());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment2.stderr b/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment2.stderr
index 6d96c62545a..0d0057a79ab 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment2.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/field_requires_parent_struct_alignment2.stderr
@@ -16,5 +16,5 @@ LL |         foo(odd_ptr.cast());
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/intptrcast_alignment_check.stderr b/src/tools/miri/tests/fail/unaligned_pointers/intptrcast_alignment_check.stderr
index 9342b269993..318004da601 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/intptrcast_alignment_check.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/intptrcast_alignment_check.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { *u16_ptr = 2 };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr b/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr
index fb588854b2a..938a0375729 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/reference_to_packed.stderr
@@ -16,5 +16,5 @@ LL |         let p: &i32 = unsafe { raw_to_ref(ptr::addr_of!(foo.x)) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr1.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr1.stderr
index daebabf4557..ae3be1ed3af 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr1.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr1.stderr
@@ -11,5 +11,5 @@ LL |         let _x = unsafe { *x };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr2.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr2.stderr
index 38902e693dc..2b926027498 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr2.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr2.stderr
@@ -11,5 +11,5 @@ LL |     let _x = unsafe { *x };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr3.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr3.stderr
index 36a13b63319..5ac4e23bf01 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr3.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr3.stderr
@@ -11,5 +11,5 @@ LL |         let _x = unsafe { *x };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr4.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr4.stderr
index 8d7a62c3850..4de90118b4b 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr4.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr4.stderr
@@ -11,5 +11,5 @@ LL |         let _val = unsafe { *ptr };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr_zst.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr_zst.stderr
index 7481179f26a..72db125074b 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr_zst.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ptr_zst.stderr
@@ -11,5 +11,5 @@ LL |         let _x = unsafe { *x };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr
index e47226ecdc7..448023a2a3d 100644
--- a/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr
+++ b/src/tools/miri/tests/fail/unaligned_pointers/unaligned_ref_addr_of.stderr
@@ -11,5 +11,5 @@ LL |         let _x = unsafe { &*x };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/uninit_buffer.stderr b/src/tools/miri/tests/fail/uninit_buffer.stderr
index 90210bf7f11..2d04c0f9be2 100644
--- a/src/tools/miri/tests/fail/uninit_buffer.stderr
+++ b/src/tools/miri/tests/fail/uninit_buffer.stderr
@@ -23,5 +23,5 @@ ALLOC (Rust heap, size: 32, align: 8) {
     0x10 │ 00 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ .░░░░░░░░░░░░░░░
 }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/uninit_buffer_with_provenance.stderr b/src/tools/miri/tests/fail/uninit_buffer_with_provenance.stderr
index 701ec601369..cd842f0eba5 100644
--- a/src/tools/miri/tests/fail/uninit_buffer_with_provenance.stderr
+++ b/src/tools/miri/tests/fail/uninit_buffer_with_provenance.stderr
@@ -28,5 +28,5 @@ ALLOC (global (static or const), size: 1, align: 1) {
     00                                              │ .
 }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/uninit_byte_read.stderr b/src/tools/miri/tests/fail/uninit_byte_read.stderr
index 9f7638888d6..b70f0ad9950 100644
--- a/src/tools/miri/tests/fail/uninit_byte_read.stderr
+++ b/src/tools/miri/tests/fail/uninit_byte_read.stderr
@@ -11,5 +11,5 @@ LL |     let undef = unsafe { *v.get_unchecked(5) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unreachable.stderr b/src/tools/miri/tests/fail/unreachable.stderr
index a57d731f1f7..f6982dc8653 100644
--- a/src/tools/miri/tests/fail/unreachable.stderr
+++ b/src/tools/miri/tests/fail/unreachable.stderr
@@ -11,5 +11,5 @@ LL |     unsafe { std::hint::unreachable_unchecked() }
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unsized-local.stderr b/src/tools/miri/tests/fail/unsized-local.stderr
index 07f94f3b91b..0ffda9e6d63 100644
--- a/src/tools/miri/tests/fail/unsized-local.stderr
+++ b/src/tools/miri/tests/fail/unsized-local.stderr
@@ -10,5 +10,5 @@ LL |     let x = *(Box::new(A) as Box<dyn Foo>);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unsupported_foreign_function.stderr b/src/tools/miri/tests/fail/unsupported_foreign_function.stderr
index 519f6d182d7..5a2f415bb84 100644
--- a/src/tools/miri/tests/fail/unsupported_foreign_function.stderr
+++ b/src/tools/miri/tests/fail/unsupported_foreign_function.stderr
@@ -10,5 +10,5 @@ LL |         foo();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/unwind-action-terminate.stderr b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
index 7575300bc57..a7543df340d 100644
--- a/src/tools/miri/tests/fail/unwind-action-terminate.stderr
+++ b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
@@ -33,5 +33,5 @@ LL |     panic_abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
index 21e403b47f8..f526f77a4f0 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_arg.stderr
@@ -11,5 +11,5 @@ LL |     g(0usize as *const i32)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr
index ccfb8890939..7d481940ace 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.stderr
@@ -11,5 +11,5 @@ LL |     f();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
index b40d99f7bc9..9e9ea710f0e 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.stderr
@@ -16,5 +16,5 @@ LL |     call(f);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr
index bd9866acbd4..7593b8a3998 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_ret.stderr
@@ -11,5 +11,5 @@ LL |     let _x = g();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/dangling_ref1.stderr b/src/tools/miri/tests/fail/validity/dangling_ref1.stderr
index 830ab9ca501..fd4dd502bd5 100644
--- a/src/tools/miri/tests/fail/validity/dangling_ref1.stderr
+++ b/src/tools/miri/tests/fail/validity/dangling_ref1.stderr
@@ -11,5 +11,5 @@ LL |     let _x: &i32 = unsafe { mem::transmute(16usize) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/dangling_ref2.stderr b/src/tools/miri/tests/fail/validity/dangling_ref2.stderr
index 4be4e8075a7..2d45ae68ca4 100644
--- a/src/tools/miri/tests/fail/validity/dangling_ref2.stderr
+++ b/src/tools/miri/tests/fail/validity/dangling_ref2.stderr
@@ -11,5 +11,5 @@ LL |     let _x: &i32 = unsafe { mem::transmute(ptr) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/dangling_ref3.stderr b/src/tools/miri/tests/fail/validity/dangling_ref3.stderr
index 4b7bdf78236..5ac4f5deffe 100644
--- a/src/tools/miri/tests/fail/validity/dangling_ref3.stderr
+++ b/src/tools/miri/tests/fail/validity/dangling_ref3.stderr
@@ -11,5 +11,5 @@ LL |     let _x: &i32 = unsafe { mem::transmute(dangling()) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_bool.stderr b/src/tools/miri/tests/fail/validity/invalid_bool.stderr
index 3972787a4d2..3ed823dde94 100644
--- a/src/tools/miri/tests/fail/validity/invalid_bool.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_bool.stderr
@@ -11,5 +11,5 @@ LL |     let _b = unsafe { std::mem::transmute::<u8, bool>(2) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr b/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr
index 5a7bd80e40c..314416766a5 100644
--- a/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_bool_uninit.stderr
@@ -11,5 +11,5 @@ LL |     let _b = unsafe { MyUninit { init: () }.uninit };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_char.stderr b/src/tools/miri/tests/fail/validity/invalid_char.stderr
index eeff289dfa4..c761669c6db 100644
--- a/src/tools/miri/tests/fail/validity/invalid_char.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_char.stderr
@@ -11,5 +11,5 @@ LL |     let _val = match unsafe { std::mem::transmute::<i32, char>(-1) } {
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr b/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr
index fb5d3ee1f1f..34babac4dd3 100644
--- a/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_char_uninit.stderr
@@ -11,5 +11,5 @@ LL |     let _b = unsafe { MyUninit { init: () }.uninit };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr b/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr
index 9234b4d705a..5d27062fbc2 100644
--- a/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_enum_tag.stderr
@@ -11,5 +11,5 @@ LL |     let _f = unsafe { std::mem::transmute::<i32, Foo>(42) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr b/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr
index 63fad1d56e3..f781ca04f03 100644
--- a/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_fnptr_null.stderr
@@ -11,5 +11,5 @@ LL |     let _b: fn() = unsafe { std::mem::transmute(0usize) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr b/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr
index 35309e90136..54781b507e0 100644
--- a/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_fnptr_uninit.stderr
@@ -11,5 +11,5 @@ LL |     let _b = unsafe { MyUninit { init: () }.uninit };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr b/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr
index cf12ab8dbd5..ed34d5255a4 100644
--- a/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_wide_raw.stderr
@@ -11,5 +11,5 @@ LL |     dbg!(S { x: unsafe { std::mem::transmute((0usize, 0usize)) } });
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr b/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr
index c234467bddc..a1bfa267cbe 100644
--- a/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr
+++ b/src/tools/miri/tests/fail/validity/match_binder_checks_validity1.stderr
@@ -11,5 +11,5 @@ LL |             _x => println!("hi from the void!"),
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr b/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr
index 8af2d37d74a..2d8238350f3 100644
--- a/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr
+++ b/src/tools/miri/tests/fail/validity/match_binder_checks_validity2.stderr
@@ -11,5 +11,5 @@ LL |             _x => println!("hi from the void!"),
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/nonzero.stderr b/src/tools/miri/tests/fail/validity/nonzero.stderr
index a9a68177ed9..2add8434ca5 100644
--- a/src/tools/miri/tests/fail/validity/nonzero.stderr
+++ b/src/tools/miri/tests/fail/validity/nonzero.stderr
@@ -11,5 +11,5 @@ LL |     let _x = Some(unsafe { NonZero(0) });
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr b/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr
index 4facd2159c8..d893f7a9e54 100644
--- a/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr
+++ b/src/tools/miri/tests/fail/validity/ref_to_uninhabited1.stderr
@@ -11,5 +11,5 @@ LL |         let x: Box<!> = transmute(&mut 42);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr b/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr
index 264465f9391..1d9c89c6880 100644
--- a/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr
+++ b/src/tools/miri/tests/fail/validity/ref_to_uninhabited2.stderr
@@ -11,5 +11,5 @@ LL |         let _x: &(i32, Void) = transmute(&42);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/too-big-slice.stderr b/src/tools/miri/tests/fail/validity/too-big-slice.stderr
index 6df00aefe75..2abe6c6fdf3 100644
--- a/src/tools/miri/tests/fail/validity/too-big-slice.stderr
+++ b/src/tools/miri/tests/fail/validity/too-big-slice.stderr
@@ -11,5 +11,5 @@ LL |         let _x: &[u8] = mem::transmute((ptr, usize::MAX));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/too-big-unsized.stderr b/src/tools/miri/tests/fail/validity/too-big-unsized.stderr
index cbcb31b29fc..bc8a140ac22 100644
--- a/src/tools/miri/tests/fail/validity/too-big-unsized.stderr
+++ b/src/tools/miri/tests/fail/validity/too-big-unsized.stderr
@@ -11,5 +11,5 @@ LL |         let _x: &MySlice = mem::transmute((ptr, isize::MAX as usize));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr b/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr
index ea155405cd6..fcd077daa38 100644
--- a/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr
+++ b/src/tools/miri/tests/fail/validity/transmute_through_ptr.stderr
@@ -11,5 +11,5 @@ LL |     let y = x; // reading this ought to be enough to trigger validation
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/uninit_float.stderr b/src/tools/miri/tests/fail/validity/uninit_float.stderr
index e95e3b18128..3d7ec44fdb0 100644
--- a/src/tools/miri/tests/fail/validity/uninit_float.stderr
+++ b/src/tools/miri/tests/fail/validity/uninit_float.stderr
@@ -11,5 +11,5 @@ LL |     let _val: [f32; 1] = unsafe { std::mem::uninitialized() };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/uninit_integer.stderr b/src/tools/miri/tests/fail/validity/uninit_integer.stderr
index 2156886cd71..55f3f803ad1 100644
--- a/src/tools/miri/tests/fail/validity/uninit_integer.stderr
+++ b/src/tools/miri/tests/fail/validity/uninit_integer.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { std::mem::MaybeUninit::<[usize; 1]>::uninit().assum
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr b/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr
index bbae9cf69ff..fed1cf45874 100644
--- a/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr
+++ b/src/tools/miri/tests/fail/validity/uninit_raw_ptr.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { std::mem::MaybeUninit::<[*const u8; 1]>::uninit().a
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/weak_memory/racing_mixed_size.stderr b/src/tools/miri/tests/fail/weak_memory/racing_mixed_size.stderr
index d35970205f2..9f92853d0ec 100644
--- a/src/tools/miri/tests/fail/weak_memory/racing_mixed_size.stderr
+++ b/src/tools/miri/tests/fail/weak_memory/racing_mixed_size.stderr
@@ -18,5 +18,5 @@ LL |         x.store(1, Relaxed);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/weak_memory/racing_mixed_size_read.stderr b/src/tools/miri/tests/fail/weak_memory/racing_mixed_size_read.stderr
index e85d76951b6..a28dec2833f 100644
--- a/src/tools/miri/tests/fail/weak_memory/racing_mixed_size_read.stderr
+++ b/src/tools/miri/tests/fail/weak_memory/racing_mixed_size_read.stderr
@@ -18,5 +18,5 @@ LL |         x.load(Relaxed);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/zst1.stderr b/src/tools/miri/tests/fail/zst1.stderr
index 07bf048ab6e..cda837da7e7 100644
--- a/src/tools/miri/tests/fail/zst1.stderr
+++ b/src/tools/miri/tests/fail/zst1.stderr
@@ -11,5 +11,5 @@ LL |     let _val = unsafe { *x };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/zst2.stderr b/src/tools/miri/tests/fail/zst2.stderr
index f42fb07edcd..b3f65e7866d 100644
--- a/src/tools/miri/tests/fail/zst2.stderr
+++ b/src/tools/miri/tests/fail/zst2.stderr
@@ -21,5 +21,5 @@ LL |     drop(x_box);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/zst3.stderr b/src/tools/miri/tests/fail/zst3.stderr
index f8b416ec348..b9495fbd207 100644
--- a/src/tools/miri/tests/fail/zst3.stderr
+++ b/src/tools/miri/tests/fail/zst3.stderr
@@ -16,5 +16,5 @@ LL |     let mut x_box = Box::new(1u8);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 

From 9b80d85722de1b6c36bb4ddd5f65710f241730a3 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 20:26:31 +0100
Subject: [PATCH 70/71] Manual find replace updates

---
 .../clippy/tests/ui-internal/default_deprecation_reason.stderr  | 2 +-
 src/tools/clippy/tests/ui-internal/default_lint.stderr          | 2 +-
 .../clippy/tests/ui-internal/lint_without_lint_pass.stderr      | 2 +-
 src/tools/clippy/tests/ui-internal/outer_expn_data.stderr       | 2 +-
 .../tests/fail/concurrency/read_only_atomic_load_large.stderr   | 2 +-
 .../miri/tests/fail/concurrency/windows_join_detached.stderr    | 2 +-
 src/tools/miri/tests/fail/concurrency/windows_join_main.stderr  | 2 +-
 src/tools/miri/tests/fail/concurrency/windows_join_self.stderr  | 2 +-
 src/tools/miri/tests/fail/memleak_rc.32bit.stderr               | 2 +-
 .../fail/stacked_borrows/retag_data_race_read.stack.stderr      | 2 +-
 .../tests/fail/stacked_borrows/retag_data_race_read.tree.stderr | 2 +-
 src/tools/miri/tests/fail/tree_borrows/write_to_shr.stderr      | 2 +-
 tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout   | 2 +-
 tests/rustdoc-ui/issues/issue-79494.stderr                      | 2 +-
 .../return-type-notation/basic.current_without.stderr           | 2 +-
 .../return-type-notation/basic.next_without.stderr              | 2 +-
 .../return-type-notation/equality.current.stderr                | 2 +-
 .../return-type-notation/equality.next.stderr                   | 2 +-
 tests/ui/atomic-from-mut-not-available.stderr                   | 2 +-
 tests/ui/consts/const-err4.32bit.stderr                         | 2 +-
 .../consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr  | 2 +-
 tests/ui/consts/const-eval/transmute-const.32bit.stderr         | 2 +-
 tests/ui/consts/const-eval/ub-nonnull.chalk.64bit.stderr        | 2 +-
 tests/ui/consts/const-eval/ub-upvars.32bit.stderr               | 2 +-
 tests/ui/consts/const-eval/ub-wide-ptr.chalk.64bit.stderr       | 2 +-
 tests/ui/consts/const-points-to-static.32bit.stderr             | 2 +-
 tests/ui/consts/invalid-union.32bit.stderr                      | 2 +-
 tests/ui/consts/issue-63952.32bit.stderr                        | 2 +-
 tests/ui/coroutine/coroutine-region-requirements.migrate.stderr | 2 +-
 tests/ui/generic-associated-types/issue-91139.migrate.stderr    | 2 +-
 .../trait-bounds/hrtb-perfect-forwarding.polonius.stderr        | 2 +-
 tests/ui/impl-trait/coherence-treats-tait-ambig.current.stderr  | 2 +-
 .../multiple-lifetimes/error-handling.polonius.stderr           | 2 +-
 tests/ui/infinite/infinite-instantiation.polonius.stderr        | 2 +-
 tests/ui/issues/issue-22638.polonius.stderr                     | 2 +-
 .../issue-37311-type-length-limit/issue-37311.polonius.stderr   | 2 +-
 tests/ui/issues/issue-40510-1.migrate.stderr                    | 2 +-
 tests/ui/issues/issue-40510-3.migrate.stderr                    | 2 +-
 tests/ui/issues/issue-59756.stderr                              | 2 +-
 tests/ui/issues/issue-67552.polonius.stderr                     | 2 +-
 tests/ui/issues/issue-8727.polonius.stderr                      | 2 +-
 tests/ui/limits/huge-array-simple-32.stderr                     | 2 +-
 tests/ui/limits/issue-15919-32.stderr                           | 2 +-
 tests/ui/lub-glb/old-lub-glb-hr-noteq1.baseleak.stderr          | 2 +-
 tests/ui/lub-glb/old-lub-glb-hr-noteq1.basenoleak.stderr        | 2 +-
 tests/ui/nll/get_default.polonius.stderr                        | 2 +-
 .../issue-38591-non-regular-dropck-recursion.polonius.stderr    | 2 +-
 tests/ui/recursion/recursion.polonius.stderr                    | 2 +-
 .../rfc-1937-termination-trait/issue-103052-2.current.stderr    | 2 +-
 .../rfcs/rfc-1937-termination-trait/issue-103052-2.next.stderr  | 2 +-
 tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.stderr          | 2 +-
 .../rfc-2627-raw-dylib/import-name-type-invalid-format.stderr   | 2 +-
 .../ui/rfcs/rfc-2627-raw-dylib/import-name-type-multiple.stderr | 2 +-
 .../rfc-2627-raw-dylib/import-name-type-unknown-value.stderr    | 2 +-
 .../ui/rfcs/rfc-2627-raw-dylib/import-name-type-x86-only.stderr | 2 +-
 tests/ui/rfcs/rfc-2627-raw-dylib/invalid-dlltool.stderr         | 2 +-
 tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr   | 2 +-
 tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr         | 2 +-
 tests/ui/type_length_limit.polonius.stderr                      | 2 +-
 59 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr b/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr
index ca26b649f98..595e4c138b4 100644
--- a/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr
+++ b/src/tools/clippy/tests/ui-internal/default_deprecation_reason.stderr
@@ -18,5 +18,5 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::default_deprecation_reason)]` implied by `#[deny(clippy::internal)]`
    = note: this error originates in the macro `declare_deprecated_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-internal/default_lint.stderr b/src/tools/clippy/tests/ui-internal/default_lint.stderr
index 8961bd4624f..ab247021025 100644
--- a/src/tools/clippy/tests/ui-internal/default_lint.stderr
+++ b/src/tools/clippy/tests/ui-internal/default_lint.stderr
@@ -17,5 +17,5 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::default_lint)]` implied by `#[deny(clippy::internal)]`
    = note: this error originates in the macro `$crate::declare_tool_lint` which comes from the expansion of the macro `declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-internal/lint_without_lint_pass.stderr b/src/tools/clippy/tests/ui-internal/lint_without_lint_pass.stderr
index de04920b8e6..de55876b1d7 100644
--- a/src/tools/clippy/tests/ui-internal/lint_without_lint_pass.stderr
+++ b/src/tools/clippy/tests/ui-internal/lint_without_lint_pass.stderr
@@ -17,5 +17,5 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::lint_without_lint_pass)]` implied by `#[deny(clippy::internal)]`
    = note: this error originates in the macro `declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-internal/outer_expn_data.stderr b/src/tools/clippy/tests/ui-internal/outer_expn_data.stderr
index e41ace4729d..0d5b0132599 100644
--- a/src/tools/clippy/tests/ui-internal/outer_expn_data.stderr
+++ b/src/tools/clippy/tests/ui-internal/outer_expn_data.stderr
@@ -11,5 +11,5 @@ LL | #![deny(clippy::internal)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(clippy::outer_expn_expn_data)]` implied by `#[deny(clippy::internal)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.stderr b/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.stderr
index 5d8cb707f3f..9fab02f9631 100644
--- a/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.stderr
+++ b/src/tools/miri/tests/fail/concurrency/read_only_atomic_load_large.stderr
@@ -15,5 +15,5 @@ see <https://doc.rust-lang.org/nightly/std/sync/atomic/index.html#atomic-accesse
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/concurrency/windows_join_detached.stderr b/src/tools/miri/tests/fail/concurrency/windows_join_detached.stderr
index 7b297b260d8..651c2eba0d9 100644
--- a/src/tools/miri/tests/fail/concurrency/windows_join_detached.stderr
+++ b/src/tools/miri/tests/fail/concurrency/windows_join_detached.stderr
@@ -18,5 +18,5 @@ LL |     thread.join().unwrap();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/concurrency/windows_join_main.stderr b/src/tools/miri/tests/fail/concurrency/windows_join_main.stderr
index ff0d074fa7d..94fe95a0bdf 100644
--- a/src/tools/miri/tests/fail/concurrency/windows_join_main.stderr
+++ b/src/tools/miri/tests/fail/concurrency/windows_join_main.stderr
@@ -9,5 +9,5 @@ LL |             assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/concurrency/windows_join_self.stderr b/src/tools/miri/tests/fail/concurrency/windows_join_self.stderr
index bbec3f7257e..0d2a22677c7 100644
--- a/src/tools/miri/tests/fail/concurrency/windows_join_self.stderr
+++ b/src/tools/miri/tests/fail/concurrency/windows_join_self.stderr
@@ -8,5 +8,5 @@ LL |             assert_eq!(WaitForSingleObject(native, INFINITE), 0);
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/memleak_rc.32bit.stderr b/src/tools/miri/tests/fail/memleak_rc.32bit.stderr
index 87c5f466bc4..3f8b7a3e819 100644
--- a/src/tools/miri/tests/fail/memleak_rc.32bit.stderr
+++ b/src/tools/miri/tests/fail/memleak_rc.32bit.stderr
@@ -20,5 +20,5 @@ note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a
 
 note: the evaluated program leaked memory, pass `-Zmiri-ignore-leaks` to disable this check
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stack.stderr b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stack.stderr
index c53a495b5e1..c6828d62d5a 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stack.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stack.stderr
@@ -21,5 +21,5 @@ LL |     let t2 = std::thread::spawn(move || thread_2(p));
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.tree.stderr b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.tree.stderr
index 1e154eb0564..675bb01b5e7 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.tree.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.tree.stderr
@@ -22,5 +22,5 @@ LL | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
    = note: inside `std::rt::lang_start_internal` at RUSTLIB/std/src/rt.rs:LL:CC
    = note: inside `std::rt::lang_start::<()>` at RUSTLIB/std/src/rt.rs:LL:CC
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/fail/tree_borrows/write_to_shr.stderr b/src/tools/miri/tests/fail/tree_borrows/write_to_shr.stderr
index 0e2002c34f1..f57b28cbf44 100644
--- a/src/tools/miri/tests/fail/tree_borrows/write_to_shr.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/write_to_shr.stderr
@@ -22,5 +22,5 @@ LL |     let xref = unsafe { &*(x as *mut u64) };
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
index f4bfb94e98c..1b37249dd60 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
@@ -12,7 +12,7 @@ error[E0425]: cannot find value `no` in this scope
 LL | no
    | ^^ not found in this scope
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0425`.
 Couldn't compile the test.
diff --git a/tests/rustdoc-ui/issues/issue-79494.stderr b/tests/rustdoc-ui/issues/issue-79494.stderr
index 7ed5ed38247..abcd69d3aae 100644
--- a/tests/rustdoc-ui/issues/issue-79494.stderr
+++ b/tests/rustdoc-ui/issues/issue-79494.stderr
@@ -7,6 +7,6 @@ LL | const ZST: &[u8] = unsafe { std::mem::transmute(1usize) };
    = note: source type: `usize` (64 bits)
    = note: target type: `&[u8]` (128 bits)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/associated-type-bounds/return-type-notation/basic.current_without.stderr b/tests/ui/associated-type-bounds/return-type-notation/basic.current_without.stderr
index 6c2645ae5bd..3666007e3d3 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/basic.current_without.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/basic.current_without.stderr
@@ -25,5 +25,5 @@ note: required by a bound in `is_send`
 LL | fn is_send(_: impl Send) {}
    |                    ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/basic.next_without.stderr b/tests/ui/associated-type-bounds/return-type-notation/basic.next_without.stderr
index 6c2645ae5bd..3666007e3d3 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/basic.next_without.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/basic.next_without.stderr
@@ -25,5 +25,5 @@ note: required by a bound in `is_send`
 LL | fn is_send(_: impl Send) {}
    |                    ^^^^ required by this bound in `is_send`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/equality.current.stderr b/tests/ui/associated-type-bounds/return-type-notation/equality.current.stderr
index d2a445f3387..26b4d935ac7 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/equality.current.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/equality.current.stderr
@@ -13,5 +13,5 @@ error: return type notation is not allowed to use type equality
 LL | fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/equality.next.stderr b/tests/ui/associated-type-bounds/return-type-notation/equality.next.stderr
index d2a445f3387..26b4d935ac7 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/equality.next.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/equality.next.stderr
@@ -13,5 +13,5 @@ error: return type notation is not allowed to use type equality
 LL | fn test<T: Trait<method() = Box<dyn Future<Output = ()>>>>() {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/atomic-from-mut-not-available.stderr b/tests/ui/atomic-from-mut-not-available.stderr
index c15d19b1594..a3edf189356 100644
--- a/tests/ui/atomic-from-mut-not-available.stderr
+++ b/tests/ui/atomic-from-mut-not-available.stderr
@@ -8,6 +8,6 @@ note: if you're trying to build a new `AtomicU64`, consider using `AtomicU64::ne
   --> $SRC_DIR/core/src/sync/atomic.rs:LL:COL
    = note: this error originates in the macro `atomic_int` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/consts/const-err4.32bit.stderr b/tests/ui/consts/const-err4.32bit.stderr
index 1cbf78173a7..582a848ca60 100644
--- a/tests/ui/consts/const-err4.32bit.stderr
+++ b/tests/ui/consts/const-err4.32bit.stderr
@@ -4,6 +4,6 @@ error[E0080]: evaluation of constant value failed
 LL |     Boo = [unsafe { Foo { b: () }.a }; 4][3],
    |                     ^^^^^^^^^^^^^^^ using uninitialized data, but this operation requires initialized memory
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
index 82de91effe7..8b941d538a2 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
@@ -9,6 +9,6 @@ LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32)
                ╾ALLOC0╼                                     │ ╾──╼
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/transmute-const.32bit.stderr b/tests/ui/consts/const-eval/transmute-const.32bit.stderr
index 09fd7998695..35a5cabaa67 100644
--- a/tests/ui/consts/const-eval/transmute-const.32bit.stderr
+++ b/tests/ui/consts/const-eval/transmute-const.32bit.stderr
@@ -9,6 +9,6 @@ LL | static FOO: bool = unsafe { mem::transmute(3u8) };
                03                                              │ .
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/ub-nonnull.chalk.64bit.stderr b/tests/ui/consts/const-eval/ub-nonnull.chalk.64bit.stderr
index 2a4b6f3b76f..fef6c92af98 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.chalk.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-nonnull.chalk.64bit.stderr
@@ -4,6 +4,6 @@ error[E0284]: type annotations needed: cannot satisfy `<usize as SliceIndex<[u8]
 LL |     let out_of_bounds_ptr = &ptr[255];
    |                              ^^^^^^^^ cannot satisfy `<usize as SliceIndex<[u8]>>::Output == _`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/consts/const-eval/ub-upvars.32bit.stderr b/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
index 353a9b78224..a6938ca0e90 100644
--- a/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
+++ b/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
@@ -9,6 +9,6 @@ LL | const BAD_UPVAR: &dyn FnOnce() = &{
                ╾ALLOC0╼ ╾ALLOC1╼                         │ ╾──╼╾──╼
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.chalk.64bit.stderr b/tests/ui/consts/const-eval/ub-wide-ptr.chalk.64bit.stderr
index 39352ca848a..533db90ce6c 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.chalk.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.chalk.64bit.stderr
@@ -4,6 +4,6 @@ error[E0282]: type annotations needed
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    |                                                                   ^^^^^^^^^^^^^^ cannot infer type for type parameter `U` declared on the function `transmute`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/consts/const-points-to-static.32bit.stderr b/tests/ui/consts/const-points-to-static.32bit.stderr
index 12cc7fbb1fc..452ed6b39d2 100644
--- a/tests/ui/consts/const-points-to-static.32bit.stderr
+++ b/tests/ui/consts/const-points-to-static.32bit.stderr
@@ -17,6 +17,6 @@ help: skipping check that does not even have a feature gate
 LL | const TEST: &u8 = &MY_STATIC;
    |                    ^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/invalid-union.32bit.stderr b/tests/ui/consts/invalid-union.32bit.stderr
index 32b67a13061..cd7549597c7 100644
--- a/tests/ui/consts/invalid-union.32bit.stderr
+++ b/tests/ui/consts/invalid-union.32bit.stderr
@@ -23,6 +23,6 @@ LL |     let _: &'static _ = &C;
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/issue-63952.32bit.stderr b/tests/ui/consts/issue-63952.32bit.stderr
index 5375ec1188a..f676d8a7586 100644
--- a/tests/ui/consts/issue-63952.32bit.stderr
+++ b/tests/ui/consts/issue-63952.32bit.stderr
@@ -9,6 +9,6 @@ LL | const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
                ╾ALLOC0╼ ff ff ff ff                         │ ╾──╼....
            }
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/coroutine/coroutine-region-requirements.migrate.stderr b/tests/ui/coroutine/coroutine-region-requirements.migrate.stderr
index 8a96d187f6b..cfee8fc44fe 100644
--- a/tests/ui/coroutine/coroutine-region-requirements.migrate.stderr
+++ b/tests/ui/coroutine/coroutine-region-requirements.migrate.stderr
@@ -7,6 +7,6 @@ LL | fn dangle(x: &mut i32) -> &'static mut i32 {
 LL |             GeneratorState::Complete(c) => return c,
    |                                                   ^ lifetime `'static` required
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0621`.
diff --git a/tests/ui/generic-associated-types/issue-91139.migrate.stderr b/tests/ui/generic-associated-types/issue-91139.migrate.stderr
index 690160577cd..23b7bf45afb 100644
--- a/tests/ui/generic-associated-types/issue-91139.migrate.stderr
+++ b/tests/ui/generic-associated-types/issue-91139.migrate.stderr
@@ -4,5 +4,5 @@ error: expected identifier, found `<<`
 LL | <<<<<<< HEAD
    | ^^ expected identifier
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/higher-ranked/trait-bounds/hrtb-perfect-forwarding.polonius.stderr b/tests/ui/higher-ranked/trait-bounds/hrtb-perfect-forwarding.polonius.stderr
index a94c80eb30b..795484f1108 100644
--- a/tests/ui/higher-ranked/trait-bounds/hrtb-perfect-forwarding.polonius.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/hrtb-perfect-forwarding.polonius.stderr
@@ -67,5 +67,5 @@ LL | | }
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: aborting due to previous error; 4 warnings emitted
+error: aborting due to 1 previous error; 4 warnings emitted
 
diff --git a/tests/ui/impl-trait/coherence-treats-tait-ambig.current.stderr b/tests/ui/impl-trait/coherence-treats-tait-ambig.current.stderr
index 61fed16294b..444f3d6689f 100644
--- a/tests/ui/impl-trait/coherence-treats-tait-ambig.current.stderr
+++ b/tests/ui/impl-trait/coherence-treats-tait-ambig.current.stderr
@@ -8,6 +8,6 @@ LL | impl Into<T> for Foo {
            - impl<T, U> Into<U> for T
              where U: From<T>;
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/impl-trait/multiple-lifetimes/error-handling.polonius.stderr b/tests/ui/impl-trait/multiple-lifetimes/error-handling.polonius.stderr
index ccd0040030d..c511081a86f 100644
--- a/tests/ui/impl-trait/multiple-lifetimes/error-handling.polonius.stderr
+++ b/tests/ui/impl-trait/multiple-lifetimes/error-handling.polonius.stderr
@@ -11,5 +11,5 @@ LL |         let _: &'b i32 = *u.0;
    |
    = help: consider adding the following bound: `'a: 'b`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/infinite/infinite-instantiation.polonius.stderr b/tests/ui/infinite/infinite-instantiation.polonius.stderr
index 29eb8c481cd..f048c942f1a 100644
--- a/tests/ui/infinite/infinite-instantiation.polonius.stderr
+++ b/tests/ui/infinite/infinite-instantiation.polonius.stderr
@@ -11,5 +11,5 @@ LL | fn function<T:ToOpt + Clone>(counter: usize, t: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/infinite/infinite-instantiation.polonius/infinite-instantiation.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-22638.polonius.stderr b/tests/ui/issues/issue-22638.polonius.stderr
index 87a7c00e410..3a94ed7bd3d 100644
--- a/tests/ui/issues/issue-22638.polonius.stderr
+++ b/tests/ui/issues/issue-22638.polonius.stderr
@@ -11,5 +11,5 @@ LL |     pub fn matches<F: Fn()>(&self, f: &F) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-22638.polonius/issue-22638.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-37311-type-length-limit/issue-37311.polonius.stderr b/tests/ui/issues/issue-37311-type-length-limit/issue-37311.polonius.stderr
index 3a1c0b82c22..08b4573dd0b 100644
--- a/tests/ui/issues/issue-37311-type-length-limit/issue-37311.polonius.stderr
+++ b/tests/ui/issues/issue-37311-type-length-limit/issue-37311.polonius.stderr
@@ -11,5 +11,5 @@ LL |     fn recurse(&self) {
    |     ^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-37311-type-length-limit/issue-37311.polonius/issue-37311.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-40510-1.migrate.stderr b/tests/ui/issues/issue-40510-1.migrate.stderr
index 776a724d310..2090530571b 100644
--- a/tests/ui/issues/issue-40510-1.migrate.stderr
+++ b/tests/ui/issues/issue-40510-1.migrate.stderr
@@ -9,5 +9,5 @@ LL |         &mut x
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-40510-3.migrate.stderr b/tests/ui/issues/issue-40510-3.migrate.stderr
index a49475a8570..59aba4a8ef8 100644
--- a/tests/ui/issues/issue-40510-3.migrate.stderr
+++ b/tests/ui/issues/issue-40510-3.migrate.stderr
@@ -11,5 +11,5 @@ LL | |         }
    = note: `FnMut` closures only have access to their captured variables while they are executing...
    = note: ...therefore, they cannot allow references to captured variables to escape
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-59756.stderr b/tests/ui/issues/issue-59756.stderr
index 9066e57aabf..27c07fecd5b 100644
--- a/tests/ui/issues/issue-59756.stderr
+++ b/tests/ui/issues/issue-59756.stderr
@@ -15,6 +15,6 @@ help: try using a variant of the expected enum
 LL |     Ok(foo()?)
    |
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/issues/issue-67552.polonius.stderr b/tests/ui/issues/issue-67552.polonius.stderr
index 9ab77d3444d..ca42f87e819 100644
--- a/tests/ui/issues/issue-67552.polonius.stderr
+++ b/tests/ui/issues/issue-67552.polonius.stderr
@@ -13,5 +13,5 @@ LL | |     T: Iterator,
    | |________________^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-67552.polonius/issue-67552.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-8727.polonius.stderr b/tests/ui/issues/issue-8727.polonius.stderr
index 283c01b6b62..4fb8c2b3aff 100644
--- a/tests/ui/issues/issue-8727.polonius.stderr
+++ b/tests/ui/issues/issue-8727.polonius.stderr
@@ -22,5 +22,5 @@ LL | fn generic<T>() {
    | ^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/issues/issue-8727.polonius/issue-8727.long-type.txt'
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/limits/huge-array-simple-32.stderr b/tests/ui/limits/huge-array-simple-32.stderr
index d1e4e6295a9..1b86b02297f 100644
--- a/tests/ui/limits/huge-array-simple-32.stderr
+++ b/tests/ui/limits/huge-array-simple-32.stderr
@@ -4,5 +4,5 @@ error: values of the type `[u8; 2147516416]` are too big for the current archite
 LL |     let _fat: [u8; (1<<31)+(1<<15)] =
    |         ^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/limits/issue-15919-32.stderr b/tests/ui/limits/issue-15919-32.stderr
index f9e48a52cb9..abd65ff3c9e 100644
--- a/tests/ui/limits/issue-15919-32.stderr
+++ b/tests/ui/limits/issue-15919-32.stderr
@@ -4,5 +4,5 @@ error: values of the type `[usize; usize::MAX]` are too big for the current arch
 LL |     let x = [0usize; 0xffff_ffff];
    |         ^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.baseleak.stderr b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.baseleak.stderr
index 4448f9326cb..0d1f9a7690f 100644
--- a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.baseleak.stderr
+++ b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.baseleak.stderr
@@ -16,6 +16,6 @@ LL | |     };
    = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
               found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.basenoleak.stderr b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.basenoleak.stderr
index 0d61311350e..83962653569 100644
--- a/tests/ui/lub-glb/old-lub-glb-hr-noteq1.basenoleak.stderr
+++ b/tests/ui/lub-glb/old-lub-glb-hr-noteq1.basenoleak.stderr
@@ -7,6 +7,6 @@ LL |         _ => y,
    = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
               found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/nll/get_default.polonius.stderr b/tests/ui/nll/get_default.polonius.stderr
index 476d86cfba9..613d06cce91 100644
--- a/tests/ui/nll/get_default.polonius.stderr
+++ b/tests/ui/nll/get_default.polonius.stderr
@@ -13,6 +13,6 @@ LL |
 LL |                 return v;
    |                        - returning this value requires that `*map` is borrowed for `'1`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0502`.
diff --git a/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.polonius.stderr b/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.polonius.stderr
index 4b4fc4fb7d1..ff1a127e63e 100644
--- a/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.polonius.stderr
+++ b/tests/ui/recursion/issue-38591-non-regular-dropck-recursion.polonius.stderr
@@ -11,5 +11,5 @@ LL | pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/recursion/issue-38591-non-regular-dropck-recursion.polonius/issue-38591-non-regular-dropck-recursion.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion/recursion.polonius.stderr b/tests/ui/recursion/recursion.polonius.stderr
index c727fe551e3..737e71e8845 100644
--- a/tests/ui/recursion/recursion.polonius.stderr
+++ b/tests/ui/recursion/recursion.polonius.stderr
@@ -11,5 +11,5 @@ LL | fn test<T:Dot> (n:isize, i:isize, first:T, second:T) ->isize {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: the full type name has been written to '$TEST_BUILD_DIR/recursion/recursion.polonius/recursion.long-type.txt'
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.current.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.current.stderr
index f72b3ab0234..f2727336bc5 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.current.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.current.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Main::main::{opaque#0}`
 LL |         fn main() -> impl std::process::Termination;
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Main::main::{opaque#0}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.next.stderr b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.next.stderr
index 8b01941b4c6..4bb420664f7 100644
--- a/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.next.stderr
+++ b/tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.next.stderr
@@ -10,6 +10,6 @@ note: required by a bound in `Main::{opaque#0}`
 LL |         fn main() -> impl std::process::Termination;
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Main::{opaque#0}`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.stderr
index cc532ccc451..0c5a06e68b8 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/dlltool-failed.stderr
@@ -2,5 +2,5 @@ error: Dlltool could not create import library with $DLLTOOL -d $DEF_FILE -D foo
        
        $DLLTOOL: Syntax error in def file $DEF_FILE:1
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-invalid-format.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-invalid-format.stderr
index fb70b987fc7..d2cf7a0ba1f 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-invalid-format.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-invalid-format.stderr
@@ -4,5 +4,5 @@ error: import name type must be of the form `import_name_type = "string"`
 LL | #[link(name = "foo", kind = "raw-dylib", import_name_type = 6)]
    |                                          ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-multiple.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-multiple.stderr
index 9533061892f..8e65baf65df 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-multiple.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-multiple.stderr
@@ -4,5 +4,5 @@ error: multiple `import_name_type` arguments in a single `#[link]` attribute
 LL | #[link(name = "foo", kind = "raw-dylib", import_name_type = "decorated", import_name_type = "decorated")]
    |                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-unknown-value.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-unknown-value.stderr
index 2bce9758e99..4b8b90eb6e2 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-unknown-value.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-unknown-value.stderr
@@ -4,5 +4,5 @@ error: unknown import name type `unknown`, expected one of: decorated, noprefix,
 LL | #[link(name = "foo", kind = "raw-dylib", import_name_type = "unknown")]
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-x86-only.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-x86-only.stderr
index b56449299b7..757f1f7994e 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-x86-only.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/import-name-type-x86-only.stderr
@@ -4,5 +4,5 @@ error: import name type is only supported on x86
 LL | #[link(name = "foo", kind = "raw-dylib", import_name_type = "decorated")]
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/invalid-dlltool.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/invalid-dlltool.stderr
index 3ae901e0dbc..9dbeee49f53 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/invalid-dlltool.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/invalid-dlltool.stderr
@@ -1,4 +1,4 @@
 error: Error calling dlltool 'does_not_exit.exe': program not found
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr
index dfd24566953..7866af59444 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr
@@ -4,5 +4,5 @@ error: multiple declarations of external function `f` from library `foo.dll` hav
 LL |         fn f(x: i32);
    |         ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr
index f69275a0125..d7c7344b596 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr
@@ -4,5 +4,5 @@ error: ABI not supported by `#[link(kind = "raw-dylib")]` on this architecture
 LL |     fn f(x: i32);
    |     ^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/type_length_limit.polonius.stderr b/tests/ui/type_length_limit.polonius.stderr
index 82d066b2a2f..bc09f159183 100644
--- a/tests/ui/type_length_limit.polonius.stderr
+++ b/tests/ui/type_length_limit.polonius.stderr
@@ -7,5 +7,5 @@ LL | pub fn drop<T>(_x: T) {}
    = note: the full type name has been written to '$TEST_BUILD_DIR/type_length_limit.polonius/type_length_limit.long-type.txt'
    = help: consider adding a `#![type_length_limit="8"]` attribute to your crate
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 

From c73d392a01f26c8f83102b12e4d66d5a8d1f558b Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Fri, 24 Nov 2023 21:36:10 +0100
Subject: [PATCH 71/71] Bless ui-fulldeps

We have to ignore some tests in stage1.
---
 tests/ui-fulldeps/dropck-tarena-cycle-checked.rs            | 2 ++
 tests/ui-fulldeps/dropck-tarena-cycle-checked.stderr        | 4 ++--
 tests/ui-fulldeps/dropck-tarena-unsound-drop.rs             | 2 ++
 tests/ui-fulldeps/dropck-tarena-unsound-drop.stderr         | 4 ++--
 tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.rs        | 1 +
 tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.stderr    | 6 +++---
 tests/ui-fulldeps/pathless-extern-unstable.rs               | 1 +
 tests/ui-fulldeps/pathless-extern-unstable.stderr           | 4 ++--
 tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.rs | 1 +
 .../session-diagnostic/enforce_slug_naming.stderr           | 4 ++--
 10 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/tests/ui-fulldeps/dropck-tarena-cycle-checked.rs b/tests/ui-fulldeps/dropck-tarena-cycle-checked.rs
index cc97971a0dd..188da67295a 100644
--- a/tests/ui-fulldeps/dropck-tarena-cycle-checked.rs
+++ b/tests/ui-fulldeps/dropck-tarena-cycle-checked.rs
@@ -1,3 +1,5 @@
+// ignore-stage1
+
 // Reject mixing cyclic structure and Drop when using TypedArena.
 //
 // (Compare against dropck-vec-cycle-checked.rs)
diff --git a/tests/ui-fulldeps/dropck-tarena-cycle-checked.stderr b/tests/ui-fulldeps/dropck-tarena-cycle-checked.stderr
index 47897dc003a..2f5be3f7f55 100644
--- a/tests/ui-fulldeps/dropck-tarena-cycle-checked.stderr
+++ b/tests/ui-fulldeps/dropck-tarena-cycle-checked.stderr
@@ -1,5 +1,5 @@
 error[E0597]: `arena` does not live long enough
-  --> $DIR/dropck-tarena-cycle-checked.rs:116:7
+  --> $DIR/dropck-tarena-cycle-checked.rs:118:7
    |
 LL |     let arena = TypedArena::default();
    |         ----- binding `arena` declared here
@@ -11,6 +11,6 @@ LL | }
    | `arena` dropped here while still borrowed
    | borrow might be used here, when `arena` is dropped and runs the `Drop` code for type `TypedArena`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui-fulldeps/dropck-tarena-unsound-drop.rs b/tests/ui-fulldeps/dropck-tarena-unsound-drop.rs
index 86485a9887f..5f9a5fb76eb 100644
--- a/tests/ui-fulldeps/dropck-tarena-unsound-drop.rs
+++ b/tests/ui-fulldeps/dropck-tarena-unsound-drop.rs
@@ -1,3 +1,5 @@
+// ignore-stage1
+
 // Check that an arena (TypedArena) cannot carry elements whose drop
 // methods might access borrowed data of lifetime that does not
 // strictly outlive the arena itself.
diff --git a/tests/ui-fulldeps/dropck-tarena-unsound-drop.stderr b/tests/ui-fulldeps/dropck-tarena-unsound-drop.stderr
index 493d74b0bde..8bb3911241d 100644
--- a/tests/ui-fulldeps/dropck-tarena-unsound-drop.stderr
+++ b/tests/ui-fulldeps/dropck-tarena-unsound-drop.stderr
@@ -1,5 +1,5 @@
 error[E0597]: `arena` does not live long enough
-  --> $DIR/dropck-tarena-unsound-drop.rs:41:7
+  --> $DIR/dropck-tarena-unsound-drop.rs:43:7
    |
 LL |     let arena: TypedArena<C> = TypedArena::default();
    |         ----- binding `arena` declared here
@@ -11,6 +11,6 @@ LL | }
    | `arena` dropped here while still borrowed
    | borrow might be used here, when `arena` is dropped and runs the `Drop` code for type `TypedArena`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.rs b/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.rs
index 39980ee7c67..39219986665 100644
--- a/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.rs
+++ b/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.rs
@@ -1,5 +1,6 @@
 // Test the `rustc::span_use_eq_ctxt` internal lint
 // compile-flags: -Z unstable-options
+// ignore-stage1
 
 #![feature(rustc_private)]
 #![deny(rustc::span_use_eq_ctxt)]
diff --git a/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.stderr b/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.stderr
index b33f6212545..fcf2565c8ab 100644
--- a/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.stderr
+++ b/tests/ui-fulldeps/internal-lints/span_use_eq_ctxt.stderr
@@ -1,14 +1,14 @@
 error: use `.eq_ctxt()` instead of `.ctxt() == .ctxt()`
-  --> $DIR/span_use_eq_ctxt.rs:12:5
+  --> $DIR/span_use_eq_ctxt.rs:13:5
    |
 LL |     s.ctxt() == t.ctxt()
    |     ^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/span_use_eq_ctxt.rs:5:9
+  --> $DIR/span_use_eq_ctxt.rs:6:9
    |
 LL | #![deny(rustc::span_use_eq_ctxt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
diff --git a/tests/ui-fulldeps/pathless-extern-unstable.rs b/tests/ui-fulldeps/pathless-extern-unstable.rs
index 7fba8343bc0..50d157c5795 100644
--- a/tests/ui-fulldeps/pathless-extern-unstable.rs
+++ b/tests/ui-fulldeps/pathless-extern-unstable.rs
@@ -1,5 +1,6 @@
 // edition:2018
 // compile-flags:--extern rustc_middle
+// ignore-stage1
 
 // Test that `--extern rustc_middle` fails with `rustc_private`.
 
diff --git a/tests/ui-fulldeps/pathless-extern-unstable.stderr b/tests/ui-fulldeps/pathless-extern-unstable.stderr
index 174cd3c2804..840b95d755c 100644
--- a/tests/ui-fulldeps/pathless-extern-unstable.stderr
+++ b/tests/ui-fulldeps/pathless-extern-unstable.stderr
@@ -1,5 +1,5 @@
 error[E0658]: use of unstable library feature 'rustc_private': this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via `Cargo.toml` instead?
-  --> $DIR/pathless-extern-unstable.rs:6:9
+  --> $DIR/pathless-extern-unstable.rs:7:9
    |
 LL | pub use rustc_middle;
    |         ^^^^^^^^^^^^
@@ -7,6 +7,6 @@ LL | pub use rustc_middle;
    = note: see issue #27812 <https://github.com/rust-lang/rust/issues/27812> for more information
    = help: add `#![feature(rustc_private)]` to the crate attributes to enable
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.rs b/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.rs
index a0a8114e0c5..33148311261 100644
--- a/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.rs
+++ b/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.rs
@@ -1,4 +1,5 @@
 // rustc-env:CARGO_CRATE_NAME=rustc_dummy
+// ignore-stage1
 
 #![feature(rustc_private)]
 #![crate_type = "lib"]
diff --git a/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.stderr b/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.stderr
index dcf4af5df50..c752a5ee057 100644
--- a/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.stderr
+++ b/tests/ui-fulldeps/session-diagnostic/enforce_slug_naming.stderr
@@ -1,5 +1,5 @@
 error: diagnostic slug and crate name do not match
-  --> $DIR/enforce_slug_naming.rs:22:8
+  --> $DIR/enforce_slug_naming.rs:23:8
    |
 LL | #[diag(compiletest_example, code = "E0123")]
    |        ^^^^^^^^^^^^^^^^^^^
@@ -7,5 +7,5 @@ LL | #[diag(compiletest_example, code = "E0123")]
    = note: slug is `compiletest_example` but the crate name is `rustc_dummy`
    = help: expected a slug starting with `dummy_...`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error