From 7d91039ac06dc34795cb141b53b610e10cbc1340 Mon Sep 17 00:00:00 2001 From: William Venner Date: Tue, 5 Jul 2022 17:19:03 +0100 Subject: [PATCH 01/74] 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 f4f2e3f24345..a5dab49c75dc 100644 --- a/library/std/src/io/mod.rs +++ b/library/std/src/io/mod.rs @@ -1923,6 +1923,28 @@ fn read_until(r: &mut R, delim: u8, buf: &mut Vec) -> R } } +fn skip_until(r: &mut R, delim: u8) -> Result { + 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 { + 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 Date: Thu, 18 May 2023 18:57:15 +0100 Subject: [PATCH 02/74] 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 9d429e7090e8..ca5d8fb4b7f9 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 Date: Thu, 18 May 2023 18:59:36 +0100 Subject: [PATCH 03/74] 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 ca5d8fb4b7f9..9d429e7090e8 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 d5a8c93b0ce9..9a9a790d77d9 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 Date: Thu, 18 May 2023 19:08:41 +0100 Subject: [PATCH 04/74] 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 a5dab49c75dc..2cbdd027036d 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 { skip_until(self, byte) } From 7c1ab71f71087d88aade79925ae68a447397422f Mon Sep 17 00:00:00 2001 From: William Venner Date: Thu, 3 Aug 2023 09:52:57 +0100 Subject: [PATCH 05/74] 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 9a9a790d77d9..4c5f86fe4316 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 Date: Mon, 16 Oct 2023 12:41:43 -0500 Subject: [PATCH 06/74] 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 c0a729481121..b7b6a9a24c9b 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 Date: Wed, 23 Aug 2023 14:46:28 +0900 Subject: [PATCH 07/74] 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 f82034663d4e..ab17a01e4112 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.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 { + 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 AsFd for &T { + #[inline] + fn as_fd(&self) -> BorrowedFd<'_> { + T::as_fd(self) + } +} + +impl 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 Date: Wed, 23 Aug 2023 14:48:50 +0900 Subject: [PATCH 08/74] 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 ab17a01e4112..6bddfc779fb4 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` 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 Date: Wed, 23 Aug 2023 16:19:58 +0900 Subject: [PATCH 09/74] 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 6bddfc779fb4..67fc94830d07 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 for OwnedFd { + #[inline] + fn from(socket: net::$t) -> OwnedFd { + unsafe { Self::from_raw_fd(socket.into_raw_fd()) } + } + } + + impl From 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 Date: Wed, 23 Aug 2023 16:46:26 +0900 Subject: [PATCH 10/74] kmc-solid: Implement `AsFd` for `{Arc,Rc,Box}` --- 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 67fc94830d07..683edc1ca855 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 {} +/// impl MyTrait for Box {} +/// # } +/// ``` +impl AsFd for crate::sync::Arc { + #[inline] + fn as_fd(&self) -> BorrowedFd<'_> { + (**self).as_fd() + } +} + +impl AsFd for crate::rc::Rc { + #[inline] + fn as_fd(&self) -> BorrowedFd<'_> { + (**self).as_fd() + } +} + +impl AsFd for Box { + #[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 Date: Wed, 23 Aug 2023 19:07:18 +0900 Subject: [PATCH 11/74] kmc-solid: Replace `{From,Into}Inner` 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 683edc1ca855..54583c73af13 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 1eae0fc0642b..4b25ca302804 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 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 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 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 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 Date: Wed, 8 Nov 2023 10:51:57 +0900 Subject: [PATCH 12/74] 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 4b25ca302804..1a7f9e347d06 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 { - 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 { - 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 { - 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 { - 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 { - 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 { @@ -220,16 +131,13 @@ impl Socket { pub fn new_raw(fam: c_int, ty: c_int) -> io::Result { 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 { - 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 { - 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 { - 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 { - 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 { - 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, 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 Date: Wed, 23 Aug 2023 19:06:43 +0900 Subject: [PATCH 13/74] kmc-solid: Implement `{From,Into}Inner` 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 1a7f9e347d06..a768e2406c8a 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 for Socket { + #[inline] + fn from_inner(sock: OwnedFd) -> Socket { + Socket(sock) + } +} + +impl IntoInner 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 Date: Wed, 23 Aug 2023 18:41:26 +0900 Subject: [PATCH 14/74] 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 54583c73af13..19b4fe22093c 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 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 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 Date: Thu, 24 Aug 2023 11:33:08 +0900 Subject: [PATCH 15/74] 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 4328ba7c3402..0bb83c73ddf7 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/74] 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 45080eda2ce2..9075a3bb8e86 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] { // 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 Date: Sat, 11 Nov 2023 16:20:06 +0300 Subject: [PATCH 17/74] print the change warnings once for per id Signed-off-by: onur-ozkan --- 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 0a6072ae1a5d..1cbe3991abfd 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 { } 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 = 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 { 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 Date: Sat, 11 Nov 2023 18:01:40 +0300 Subject: [PATCH 18/74] refactor change-tracking implementation Signed-off-by: onur-ozkan --- 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 1cbe3991abfd..eb3fa0783a19 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 { 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 { } } - let change_links: Vec = 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 { } 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 486a1e20f183..bbbdb4c3186d 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 33b8f1a7ce72..0351ec53824f 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 { - if !CONFIG_CHANGE_HISTORY.contains(¤t_id) { +pub fn find_recent_config_change_ids(current_id: usize) -> Vec { + 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 ¤t_id > max_id { + if let Some(config) = CONFIG_CHANGE_HISTORY.iter().max_by_key(|config| config.change_id) { + if ¤t_id > &config.change_id { return Vec::new(); } } @@ -1864,7 +1907,8 @@ pub fn find_recent_config_change_ids(current_id: usize) -> Vec { 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 Date: Sat, 11 Nov 2023 18:11:02 +0300 Subject: [PATCH 19/74] remove .last-warned-change-id on `x clean` Signed-off-by: onur-ozkan --- 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 cbb6b5f46488..a3fb330ddfb6 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 Date: Sun, 12 Nov 2023 13:26:04 +0300 Subject: [PATCH 20/74] bootstrap: add doc-comments for `ChangeSeverity` Signed-off-by: onur-ozkan --- 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 0351ec53824f..00fe4422e5c3 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 Date: Sat, 11 Nov 2023 21:29:32 +0300 Subject: [PATCH 21/74] 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 --- 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 eb3fa0783a19..35010bea8187 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 { "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/74] 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 0978b3c92805..f10a82c56949 100644 --- a/library/core/src/cell.rs +++ b/library/core/src/cell.rs @@ -409,8 +409,7 @@ impl Cell { #[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 Date: Tue, 7 Nov 2023 05:42:46 +0000 Subject: [PATCH 23/74] 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 a349e24b0395..795e1c160415 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 38bf15b7c720..5cd738c2930a 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 e0509e6a5dd7..221dc2346a80 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 Date: Fri, 17 Nov 2023 12:13:38 +0000 Subject: [PATCH 24/74] 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 92bac995bc61..52640036f9e0 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 5cd738c2930a..f91e1054a040 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 221dc2346a80..b38b70c8983e 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 9821677a1226..d8a7a06efc6d 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 Date: Fri, 17 Nov 2023 19:54:37 -0500 Subject: [PATCH 25/74] Document behavior of `::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 8f5404d9713d..22777fb078a2 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?= Date: Sun, 12 Nov 2023 10:48:29 +0100 Subject: [PATCH 26/74] 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 dbbce6fe2204..d32c3e78d5e5 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 d2aa89dee284..dc9b56f30db1 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 cd276674dee6..301d3dfe2997 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 5bc81f2d983e..c53cc626b971 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 { 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 Date: Sun, 19 Nov 2023 16:24:39 +0000 Subject: [PATCH 27/74] 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 f4078d359448..3b22f6d2e315 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 Date: Mon, 20 Nov 2023 11:50:18 -0700 Subject: [PATCH 28/74] 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 Date: Mon, 20 Nov 2023 11:50:25 -0700 Subject: [PATCH 29/74] 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 0fe680f10af3..ec21a68c4ee5 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 fa57c58c7618..6c81df110856 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 c32bcf380ea3..d481dc0dd701 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 ef6ed104b743..6386aa75a95e 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 36ab739565b8..ea6b7bac4c7a 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 de772881e732..3b16ad2045a3 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 b429bf8c9ba7..42e57ac72587 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 af1b32fd22b1..9f091384dfeb 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 c59f8c72e64c..e51cee2f0563 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 b35743d887bf..68dda3a25bbf 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 4d2e4c17b1f9..fafa45971748 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 b38ef20c551f..820a63f34989 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 4b3456b86c5e..c38dc2810cf3 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 37da3dd19997..7bc92cca1afd 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 810ddca3eab8..8944bdd42b4f 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 95d551934593..c16837b61297 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 8a5f0413826a..77b8c05f2fbe 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 {} // @has 'foo/struct.Foo1.html' diff --git a/tests/rustdoc/tuple-struct-34928.rs b/tests/rustdoc/tuple-struct-34928.rs index 4184086f622a..909b91468931 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(pub T) where T: Bar;' From cbe68435c603da438b8994c1a583b46fc01821cf Mon Sep 17 00:00:00 2001 From: Michael Howell Date: Mon, 20 Nov 2023 11:59:29 -0700 Subject: [PATCH 30/74] 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 c16837b61297..07e672847ca6 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 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/74] 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 07b172bc757b..43874a242f26 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 = 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 1a377feb9194..000000000000 --- 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 0f6f67043f32..000000000000 --- 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 000000000000..2024a55200bd --- /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 000000000000..05fb6fecffae --- /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 Date: Wed, 22 Nov 2023 07:25:27 +0100 Subject: [PATCH 32/74] 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 b11b190bdeda..86e1825d7b53 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 Date: Wed, 22 Nov 2023 15:28:09 +0800 Subject: [PATCH 33/74] 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 f2c1f84fccc1..726bda76b01d 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; /// 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, condvar: Condvar, @@ -198,13 +199,14 @@ impl QueryWaiter { } #[cfg(parallel_compiler)] +#[derive(Debug)] struct QueryLatchInfo { complete: bool, waiters: Vec>, } #[cfg(parallel_compiler)] -#[derive(Clone)] +#[derive(Clone, Debug)] pub(super) struct QueryLatch { info: Arc>, } @@ -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 6c08df99e9da..ecbc7dc6b8f4 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" Date: Tue, 21 Nov 2023 13:41:02 -0800 Subject: [PATCH 34/74] 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 403c7703debc..dea881a2bb38 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 000000000000..accd078b1ce7 --- /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 6c1b723a8dae..1b1faea49539 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; /// 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; + 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 9cec963cf849..ddf601f6d763 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 { with(|context| { @@ -104,6 +118,8 @@ impl TryFrom for Instance { fn try_from(item: CrateItem) -> Result { 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 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 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 c7422d66c0e8..c16d7ddf335b 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 010e2e7e4a69..cf97d1a6f0b0 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 e5fb7311c0b8..170b1fd73b16 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 000000000000..bbb495962888 --- /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::::new", "std::vec::Vec::::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 { + 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::>() +} + +/// 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::::new(); + }} + "# + )?; + Ok(()) +} diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs index 4164f041022d..c2035430a33b 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 299307635913..8c3fda7b6bb1 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" Date: Tue, 21 Nov 2023 19:09:01 -0800 Subject: [PATCH 35/74] 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 fe226ef60ed4..202ca1b156aa 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 Date: Thu, 23 Nov 2023 00:27:34 +0300 Subject: [PATCH 36/74] 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 --- 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 a1f6fac8a518..f710c01ca33c 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 a57b09e2ef68..c6e279ca9d83 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 { .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 Date: Sat, 18 Nov 2023 19:29:39 +0000 Subject: [PATCH 37/74] 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 80b21bd8ece2..2db610d640c2 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` 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 93c7c37c6550..98bafc0f2637 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() // `::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 7fe488e12432..9fda53c25334 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, + pub label2: Option, } #[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 dd4aa8e9a078..557a4420a3db 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>` 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 dfca7b0fa68f..68838d2ae20d 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 0f7a61dfa808..5a13659edf56 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` 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 000000000000..366eae1a58a3 --- /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 {} +impl Bar for T {} + +trait Foo: Bar { + fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar + 'a); +} + +impl Foo for () { + fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar + 'a) { + self + } +} + +impl<'a> Deref for dyn Foo + 'a { + type Target = dyn Bar + 'a; + + fn deref(&self) -> &Self::Target { + self.as_dyn_bar_u32() + } +} + +fn take_dyn(x: &dyn Bar) -> 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 000000000000..e8bab322a383 --- /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 000000000000..2c9126c863d5 --- /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 {} + +trait Foo: Bar { + fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar + 'a); +} + +impl<'a> Deref for dyn Foo + 'a { + //~^ WARN this `Deref` implementation is covered by an implicit supertrait coercion + type Target = dyn Bar + '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 000000000000..a447f9cf83b7 --- /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>` which conflicts with supertrait `Bar` +LL | +LL | type Target = dyn Bar + '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 Date: Wed, 22 Nov 2023 23:28:28 +0000 Subject: [PATCH 38/74] 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 b502590c1bfb..6fbab0ef2990 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> 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 5735c5568f79..9b41b77928e6 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>, - [] consts: rustc_middle::ty::ConstData<'tcx>, + [] consts: rustc_type_ir::WithCachedTypeInfo>, // 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 c46ab9923592..0f5817c78e0a 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>>); /// 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 62b0536dabee..3e24b7cce867 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>>, projs: InternedSet<'tcx, List>, place_elems: InternedSet<'tcx, List>>, - const_: InternedSet<'tcx, ConstData<'tcx>>, + const_: InternedSet<'tcx, WithCachedTypeInfo>>, const_allocation: InternedSet<'tcx, Allocation>, bound_variable_kinds: InternedSet<'tcx, List>, layout: InternedSet<'tcx, LayoutS>, @@ -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>>( &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): 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 4d7b12662c66..de829f7f9775 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 0c658fa1c80f..c1063d6a5f00 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> as usize) } }; @@ -136,7 +136,7 @@ impl<'tcx> GenericArg<'tcx> { &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo>), ))), CONST_TAG => GenericArgKind::Const(ty::Const(Interned::new_unchecked( - &*((ptr & !TAG_MASK) as *const ty::ConstData<'tcx>), + &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo>), ))), _ => intrinsics::unreachable(), } diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs index 1d7abcf53ea3..0f34de2c09d9 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>), ))), CONST_TAG => TermKind::Const(ty::Const(Interned::new_unchecked( - &*((ptr & !TAG_MASK) as *const ty::ConstData<'tcx>), + &*((ptr & !TAG_MASK) as *const WithCachedTypeInfo>), ))), _ => 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> as usize) } }; diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs index f14232d34352..e1ce941256c9 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> for HasEscapingVarsVisitor { } fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow { - // 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> for HasTypeFlagsVisitor { #[inline] fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow { // 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 dba00ce0154b..8faaa6be9f56 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> for MaxEscapingBoundVarVisitor { } fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow { - 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 Date: Thu, 23 Nov 2023 10:35:33 +0800 Subject: [PATCH 39/74] 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 726bda76b01d..b38d71733b59 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 Date: Sun, 19 Nov 2023 16:17:48 -0500 Subject: [PATCH 40/74] 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 d5b165a7415b..1c1fd2a71ba1 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) { + // 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 eac4aad27a0c..ef6d49f041fc 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) { - 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?= Date: Wed, 11 Oct 2023 21:26:14 +0200 Subject: [PATCH 41/74] 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 dc9b56f30db1..4e7aeabd06b8 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 301d3dfe2997..15097825d4d0 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 c53cc626b971..89fa2b805cd1 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 { #[cfg(windows)] fn absolute_windows(path: &std::path::Path) -> std::io::Result { - 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 { 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 { + 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 Date: Thu, 23 Nov 2023 18:55:11 +0800 Subject: [PATCH 42/74] Bump `unicase` crate version. --- Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8c9b12028f09..3af057f5e3d1 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/74] 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 fd5d6fabf021..d078cbefde93 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 3a25e25eede6..76dc1dad80a9 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 67705fe063a7..f1edf65a7261 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 3f6a3da4be2b..8d97dbeb14a7 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 Date: Thu, 23 Nov 2023 12:25:41 +0000 Subject: [PATCH 44/74] 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 9119792e3243..f3993ec25667 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 = >::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 0378ac6e8ec9..454dbecc7d01 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> for &'b Wrapper where S: Unsize {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -9,18 +9,18 @@ LL | impl<'a, 'b, T, S> CoerceUnsized<&'a Wrapper> for &'b Wrapper where S where 'b: 'a, T: Unsize, 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> for &'b Wrapper where S: Unsize {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | 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> for &'b Wrapper where S: Unsize {} | ^^ 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> for &'b Wrapper where S: Unsize {} | ^^ diff --git a/tests/ui/error-codes/E0476.old.stderr b/tests/ui/error-codes/E0476.old.stderr new file mode 100644 index 000000000000..454dbecc7d01 --- /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> for &'b Wrapper where S: Unsize {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: conflicting implementation in crate `core`: + - impl<'a, 'b, T, U> CoerceUnsized<&'a U> for &'b T + where 'b: 'a, T: Unsize, 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> for &'b Wrapper where S: Unsize {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | +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> for &'b Wrapper where S: Unsize {} + | ^^ +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> for &'b Wrapper where S: Unsize {} + | ^^ + +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 d5e4b8d23727..e9afc7567260 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 Date: Thu, 16 Nov 2023 19:08:30 +0300 Subject: [PATCH 45/74] 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 35726ba52bcd..e34661d5fc6d 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 ea80bc82bd1f..40b038742422 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 000000000000..6ac367120903 --- /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 000000000000..1f55c1f250a3 --- /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 Date: Thu, 23 Nov 2023 01:56:09 +0100 Subject: [PATCH 46/74] 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 8fdbef65135c..927bec4251e5 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 000000000000..bc6ddbe5defa --- /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 Date: Thu, 23 Nov 2023 11:16:10 -0800 Subject: [PATCH 47/74] 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 d00e79476f38..5bf0154eae30 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/74] 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 rather than Option 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 ff71a567ed3a..aa50dbfdf35b 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 2ccdc7d78748..3cf295c003e4 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 000000000000..14bd23e77ea0 --- /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 { + gen { yield 42; for x in 3..6 { yield x } } +} + +fn moved() -> impl Iterator { + 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 ebeca8662a51..0f884187addd 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 aa4d8ddad566..42540911785b 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 @@ -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 737acfbc6005..8ea78b9b532f 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` + 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` + 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` 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 88700779e87b..e292a3107420 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" Date: Thu, 23 Nov 2023 12:29:20 -0800 Subject: [PATCH 49/74] 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 dea881a2bb38..b8009b3ee49b 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::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 accd078b1ce7..70ca9e6825e1 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 ddf601f6d763..8e884f175736 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::new`. pub fn name(&self) -> Symbol { with(|context| context.instance_name(self.def, false)) } @@ -118,8 +124,8 @@ impl TryFrom for Instance { fn try_from(item: CrateItem) -> Result { 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/74] 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 8ea78b9b532f..ae3684642565 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` - 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` + 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` + 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` - 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` + 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` - 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/74] 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 ae3684642565..85e137d29ac4 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 Date: Thu, 23 Nov 2023 14:54:19 -0700 Subject: [PATCH 52/74] 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 e51cee2f0563..c17688e3b1d7 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 68dda3a25bbf..46367ccaef9a 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 42e57ac72587..f3107d2379c9 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 9f091384dfeb..755fc1cfdff2 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 820a63f34989..d2ac38f3e455 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 c38dc2810cf3..210b1e79cd2f 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 fafa45971748..a06e977b10a5 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 Date: Fri, 10 Nov 2023 08:14:02 +0000 Subject: [PATCH 53/74] 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 0e260e69c85a..ea399cda53a8 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 Date: Thu, 23 Nov 2023 14:56:03 -0700 Subject: [PATCH 54/74] 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 000000000000..d11c69f812a8 --- /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 Date: Thu, 23 Nov 2023 20:10:44 -0500 Subject: [PATCH 55/74] 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 ffafdba13cea..b34d3dd90440 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, } @@ -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 WorkerLocal { { 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 8df3648a065d..b3ab01a740a9 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 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 Date: Thu, 23 Nov 2023 20:15:29 -0500 Subject: [PATCH 56/74] 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 c982e2a93253..22f3d733dc3e 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 f4a8ada8f685..ac3538f181ee 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>, 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::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 Date: Thu, 23 Nov 2023 17:16:19 -0800 Subject: [PATCH 57/74] 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 90be2050d926..5d8286d8116f 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 Date: Thu, 23 Nov 2023 16:38:31 -0800 Subject: [PATCH 58/74] 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 927bec4251e5..ce9e1bcf4883 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 5d8286d8116f..c4d7118d07ff 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 Date: Thu, 23 Nov 2023 21:47:08 -0500 Subject: [PATCH 59/74] 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 65946e09ff9b..9ef0a7d76084 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 Date: Fri, 24 Nov 2023 09:45:23 +0100 Subject: [PATCH 60/74] 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 35010bea8187..7e6fdb7092de 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::>(); From a5dff378f54821b763ffd06ff3d2702777c055d6 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Fri, 24 Nov 2023 11:15:53 +0100 Subject: [PATCH 61/74] 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 921a0fb6a9f8..d44cf299c278 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 Date: Fri, 24 Nov 2023 15:20:02 +0100 Subject: [PATCH 62/74] 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 c47152c601c3..67b6801059af 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 23ce0a301ce7..e9d7e6675b47 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>>, } -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 65d061ab3f44..0cf4799f86d0 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 Date: Fri, 24 Nov 2023 14:32:05 +0000 Subject: [PATCH 63/74] 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 83fe95f16f9a..10776f31c07b 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 e9554f107765..96af090bccd2 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 1a45c8eb1a53..45b5e63bd1b3 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 da91c3c8a199..a3bf47328eaf 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 7de46994434c..9a8d0d691f09 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 75617b1b3ea5..b1a57c3dfd97 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 127aff913e37..8ca271503711 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 e6b663c47d75..1b88839984f4 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 7df16ca5a3b4..290ef6e2f5fa 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 9210f6427064..db48c170d1c0 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 be75e852e0ac..217b02f68adb 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(pub core::marker::PhantomData); - | ^^^^^^^^^^^^^^^^ + | ^^^^^^ | = 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 be75e852e0ac..217b02f68adb 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(pub core::marker::PhantomData); - | ^^^^^^^^^^^^^^^^ + | ^^^^^^ | = 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 204f0f9f89ff..12bcdb034bc2 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 06330958b8e0..d705244c0ee1 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 77b13a351e2b..e10c51ef45ab 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 2e41eb9b4c45..34f6515b572e 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 be7a83dc1841..b479793814cb 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(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(_: Foo) -> 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 c14f9a990358..c6e18924fd81 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() {} - | ^^^^^^^^^^^^ + | ^^^^^^ | 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 { 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); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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; - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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 { 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 { 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; - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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: () = (); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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: ~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: ~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(); - | ^^^^^^^^^^^^ + | ^^^^^^ | 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: (); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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 = (); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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() {} - | ^^^^^^^^^^^^ + | ^^^^^^ | 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: () = (); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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 = (); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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() {} - | ^^^^^^^^^^^^ + | ^^^^^^ | 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: () = (); - | ^^^^^^^^^^^^ + | ^^^^^^ | = 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 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 3d6fedbabbf6..abe24b662a27 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(); - | ^^^^^^^^^^ + | ^^^^^^ | 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 813e65e45a25..e6da83296ce1 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 Date: Fri, 24 Nov 2023 14:51:48 +0000 Subject: [PATCH 64/74] 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 a9f67f984da8..6d4bd981b7b4 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/74] Show number in error message even for one error Co-authored-by: Adrian --- 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 1cee57843f07..a3cda5aeab54 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 a9f67f984da8..64feae0c6af4 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 0d8a306ace5e..34a61e76fcf6 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 3b346e00227a..d31cc2a896f7 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 eb739b149a10..3be219bdb064 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 dfff2a7e7094..ad640767fee1 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 5e47b0f0cc7a..3c0ba9580f7a 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 7a914c2a3907..1eecbc0a97b1 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 b1fb4421ea04..f1e4b093cc6d 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 a3079113d01c..bf0f3a7c637a 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 205a852983a3..bb3817421df1 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 edd72b53eb3b..bde87475e0a6 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 dfb47e010e49..17bde4d97433 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 4d18b97c98be..887bf82a2f6f 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 de221ba1fe18..3768367a5e61 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 082564fbc7f8..6bdb734fddfa 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 f64a83ab7106..72e6fec27e62 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 f2c47d353efa..eed3964559ab 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 bcf36e37cdcc..9c83b47f8b64 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 bb6f06a35c6c..04ee9275cb36 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 70cc60255c71..65b3d285100d 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) {} | ^^^ ---------- --------------- -error: aborting due to 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 3b92cc76687b..d16e8d50dfdd 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 591db268a994..f9ba2f13911b 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 5e531a993c62..3ed0d6bdf3ac 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 c33919c41cdc..8cc2c6e03974 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 7d34defc1d57..288031e505cf 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 47008e1d9994..7e5b8afea24b 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` -error: aborting due to 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 ec4a001f4d01..b3f953af6d27 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 679fd8997733..d9343140fb1d 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 7511271361de..cf5796f7e4a4 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 -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 619417a73c9e..24b6abfb3426 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 = 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 f8e65b6f5381..c44ba3c91d91 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 49013a23ced2..13f39e7def96 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 996b0933a341..8466a53be299 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 de3e28fdd122..762f3d02a41a 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 47386ffa4a8c..1703d2977a72 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 2758a4ac4377..2767a6d54ed7 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 2395566de394..a4dd8e0a9598 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 bba5d8dffe4b..d92485de68fe 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 e39224f2c164..42d722291c38 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 = ::ID; LL | const X: i32 = ::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 e3db45810fdd..f804cf20591f 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 7e485a314c54..33f5a5ceedf1 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 d45868151b16..5ea85ff3b989 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 `::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 742b81535dfd..6037122a365d 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 f3616035fc7d..b91b777d5850 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 60bbe385c019..59acd4820aea 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 fe27da5ac645..7ded05b7b48e 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 a3fa3002e1ef..13bde56a680f 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 0bc019b2dc87..cd8303942856 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; ::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 46a54a12d624..3234945e0dff 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; ::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 e29c32f5dfda..9cee03041fe6 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 ac5ec8e05ea9..091a50f9463b 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 ba4e6a23e27e..67834788ccd4 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 f8c02420f96a..e946491a0848 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 531d15c5900c..b69dfd51ea8c 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 = 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 4418fb7556bd..21062fdaf585 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 392cd5e3443a..e4abf6203e8f 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 6cbddca9c62a..05ebd76f5001 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 2e4ddb81166b..7382426b0ffa 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 8175e510a093..91bfcf29cb37 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>() {} | ^^^^^^ 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 fe21d2aec00b..a01a9ae561fd 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 155c296cbb3c..09e6c1397037 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 387a5658da37..c332416c6f31 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: `= ;` -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 415ee0193c94..cf2aee6ab53e 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 3c373f139cbe..a2ad4cbde01c 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 ab6a97b3d858..b3d55fea14b5 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 fcf828c21c7c..585983405388 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; | ^^^^ 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 94c20521857f..1be65687a3e8 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 f29144e4aa75..bf329c69e99c 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 dc59b56ee207..c25ffb9d9c2a 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 Fn() -> Lexer::Cursor; = note: the associated type was found for - `Lexer` -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 63f50732d3c5..1e11c0e8c2af 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 c55f1432389c..2c78e3a1fb78 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 fn(Foo::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 f6367c88aea6..f60fd58c23b6 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` LL | pub type Focus = &'a mut for<'b> fn(Carrier<'b>::Focus); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 bf35f2bb5b53..eb3329dc5e98 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::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 0dd17b05cd0d..fba3a5b85337 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 16bb64281e3a..7f991a53c9bb 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 3561db354c03..9bd5a842fdc7 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::::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 9206b4f6db7e..978305c2ce35 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::::Pr = (); | ^^^^^^^^^^^^^ help: use fully-qualified syntax: ` 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 230bfa538b4f..0d5f781dc633 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); = 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 3ddab25deb54..650b5946064c 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::::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 3a438ee630e1..32e6d8e465a0 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 b0a4ed35d560..4c68a591240f 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 f83061f8c421..12e4d545ab1d 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 ecf30f4cdec5..7ce69a94bf8c 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 S { 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 d4968cd05dce..cb35cdde0b4b 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::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 f7a47be8dc39..9e1dd7398079 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: >::Ty; | ^^^^^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: ` 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 f2e4ca524a43..0c8dc9d7fd69 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 0b96a6bd7c00..ee0686b0f912 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 6f753845ac85..fbd2434003a4 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 f2604f0ba881..9b077a4d3eff 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 {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = 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 a32ab453152a..7942992874da 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 6fa266d23d49..fe300a7de427 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:, | ^^^^^^^^^^^^^ -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 8b66627d57fe..7bdb2c5a7c29 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 {} | ^^^^^^^^^^^^ -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 f71f72bfb94f..d09ad73a61f1 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 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 0f1ec9ad0522..0b6207074979 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>() {} | ^^^^^ 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 bf0824259a5a..e782571c7dea 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>() {} | ^^^^^ 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 ddfb6612b081..eef24c8827bd 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) {} | = 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 78bf93c32d57..1f99d7db0b02 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 8777b2965153..561ca15ab0d0 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 = ()>; | ^^^^^^^^^ 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 35435962ffe9..65c89735c5dc 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:, | ^^^^^^^^^^^^^ -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 09c8ec2e289f..6abaaf8e182b 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 Iterator>() { 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 5b96676d037c..f576cc9c95f0 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 1a2f84715243..d432e9577354 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>>>() {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 fb6538fa05c4..3ca5e66866d1 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>() {} | ^^^^^^^^^^^^^^ -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 31b793995f8a..3e307c5f42ca 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>() {} | = 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 77e015b4160b..f27603e3719d 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>() {} = note: see issue #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 b104f38ce908..7ca9aff43227 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 `::M` to `u8` LL | impl> U 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 6a4cf99c474e..dc540a475c35 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 fbc4ccd4cf44..ebe56c8cd689 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 { | ^^^^^^^^^^^^^^^^^^^ -error: aborting due to 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 3eda22796e09..0b404819c2c0 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, ::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 e9ace7d2574b..14ef36876740 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(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 23ee8cd23b5c..447b8413ee29 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(x: &>::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 bd354cf3e16f..7559f3b7c2e5 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::::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 6552c8be7808..17941b6bf1ee 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(&self, foo: U, bar: ::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 676d6353d985..adde31b4a321 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 + 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 E0277`. diff --git a/tests/ui/associated-types/associated-types-issue-17359.stderr b/tests/ui/associated-types/associated-types-issue-17359.stderr index 9e40d8095862..f5397b8ecdc9 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 f384079862fb..8e6b847b3aac 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>(_: &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 b2ee1b5e6d04..fe1be6be0155 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(foo: ::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 2e40dbd065d3..b586053a5bc9 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(&self, foo: U, bar: ::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 2fe3f2d4a025..deeedd222669 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 fdec01b95e3b..4dfd275a1905 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 = &vec![42].into_iter(); | = note: required for the cast from `&std::vec::IntoIter` to `&dyn 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/associated-types/associated-types-project-from-hrtb-in-fn.stderr b/tests/ui/associated-types/associated-types-project-from-hrtb-in-fn.stderr index c508006c3a49..83bad291e566 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: >::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 2e67c21940fc..64a88525af8d 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(&self, foo: U, bar: ::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 ef9b7cae01bb..4221a064ff9c 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 = ::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 bec9b1500c9d..e46b2a394640 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: T) where ::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 4de4afb6e924..8ccfb2122167 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 &'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 b709fae5a8e5..435e224bd892 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 7753d186504f..0593a62a7507 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 788cf667c8d2..138b777e664e 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 1c0d3ac10585..1815a7be7ee8 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 f7833500d00c..c7d097d37462 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 6d8ab2c3fdc7..6ae13e9222a3 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 b64cb2c3d0b6..b8100f6dfaec 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 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 fc830b8d6768..aeb4e47abcbf 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 3ecac9c83e57..606084aea34a 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<::Item>` found enum `Option<&::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 239f45539386..09606a1944d5 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 | ^^^^^^^ -error: aborting due to 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 b380a1b6f065..ab5dc803cdf4 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> >::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 8ccbc9fb5144..2a7d75ef29be 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> >::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 a0a6f76a5837..8c91211b964b 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> >::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 e249f2e0c279..9e0393642249 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> >::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 f49439d3573d..f8be4ec24105 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> >::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 f8733b423d77..22c4bd68690e 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 bd6e627a3d0d..da988f4cfc1b 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 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 425cfdca01d1..59b52521ef80 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> 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 fbd76a64c1e9..24409b32ad3e 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 `::Item` to `i3 LL | fn bar() -> impl 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/associated-types/impl-wf-cycle-1.stderr b/tests/ui/associated-types/impl-wf-cycle-1.stderr index 53022dcb4c78..5fa36733f667 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 81c58be927e6..17a96bbd9343 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 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 bd6a86b74208..35184e852cfe 100644 --- a/tests/ui/associated-types/issue-19883.stderr +++ b/tests/ui/associated-types/issue-19883.stderr @@ -10,6 +10,6 @@ LL | >::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 c8e57df0d9fe..02470a442491 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 { | ++++++++ -error: aborting due to 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 02b3536e2d15..e4f1fc62387c 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 { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = 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 0e019f10f37f..b02dad97d354 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) -> ::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 3443c4925f4e..f9d58c23cbba 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; | ------------- `Children` defined here ^^^^^^^^^ help: specify the associated types: `Hierarchy` -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 73effa9f9553..2671bf57d0c4 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; | ^^^^^^^^^^^^^^^^^^^^^^ 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 fa309a55c3c2..4e432c0e702a 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 977620d9052f..b64bcee07f04 100644 --- a/tests/ui/associated-types/issue-26681.stderr +++ b/tests/ui/associated-types/issue-26681.stderr @@ -9,6 +9,6 @@ LL | const C: ::Bar = 6665; = note: expected associated type `<::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 a14a273b3ece..70bf90150b8f 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: &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 8212c607e112..6b0ef1efdd0e 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 `>::Out` to `()` LL | pub fn f<'a, T: Tr<'a, Out = ()>>() -> >::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 7f8f13ef8d4a..3d6f11faff78 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 80e42b61d205..dd91bac81586 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 a52a9c138f14..8b628f5ae6d1 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::Nullable>, ::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 50fa7d1ac4d4..529fc1f119a9 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 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 73365d64d560..384b8685a1e7 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, | -------------- 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 2e4ddb81166b..7382426b0ffa 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 6ff5e4542343..f300208fcc87 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, ::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 04f0728f58ea..7b040f8aa147 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(>::A) -> >::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 f643ec3ff1fd..67151431a67a 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 f1016f0e3a19..7c09abdb3b6f 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 e95943f34d54..9cb615bbb288 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; | ^^^^^^^ 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 0bdea10ba474..c79543e73cd0 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 9afbe82c3219..1c9de509e683 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; | ^^^^^^^^^^^ 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 8e7cf86c4066..99a46dedcdce 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 + Sub + Mul + Div + 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 10691aad04e8..1d8d1c67bae1 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 224198653dc5..4b0139a396c4 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 eaa455380505..99bce89e8d3b 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 0996c38b3b6c..7948fb9564e0 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 47a5dcebf25d..0104736976d5 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(mut f: dyn Future + Unpin) -> T { = help: the trait `Sized` is not implemented for `(dyn Future + 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 b5c8ef6993d6..3374068ed3f6 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 10b15170922f..06f3e34629a5 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 d80467c7fa88..1dade23f6231 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 e65d9d0e5d35..1faaf4ddce2f 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` -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 1fa4e5db0cbb..45a226c31f84 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 6c235916d647..9fce4d61b3b6 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) {} | ^^^^ 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 485a838b67ff..c69a0dd9ed98 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 dc160bfbf617..120f1c9b00d0 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 3037d7024472..418a0829c657 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) {} | ^^^^ 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 8fd2550c1c77..0e2da190af71 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 b70b36adb4a5..34aded73da55 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 + '_>>; = note: expected signature `fn(&i32) -> Pin>>` found signature `fn(&i32) -> impl Future` -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 6392ce86e4a0..1462c694e161 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 + '_>> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 1eda6fe6532a..a2f1060e36fc 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 cf0bcd741fc3..11489c18ad40 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 b959652ea167..587962857269 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 cd085074ae34..f75ccb65d150 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 647cc698f9f5..5f7aeb17117b 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() {} | ^^^^^^^^^^^^^^ 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 ce02c1e99675..95731b67ccf7 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 3841ab9345fa..6b8716d2a8d2 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 139bd06c7df0..aeabb5931dfc 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 + 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 5b9fd98ac60e..f45e6a2c8bb5 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 a66dd13bb7a1..84e0a643485f 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>; | ^^^^^^^ 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 363870619f05..4947b7fec9d1 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 482707351d74..dd38e205b03f 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 2cb0da2e8bc0..ef7e4ef0eb85 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 d0278628c97b..c741a23c6d56 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 + 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 5367b986d2b8..782fa4295fd7 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 d161fb0c05e7..f6af15c00d62 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 588669092b01..6a80bc149106 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 207e085d273f..5428d7ef71b3 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: 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 a433c76ae708..f05e954d2d71 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: 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 4bbb7731b110..3ac30bdc23e6 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: 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 cb02fcf5ce78..d28807e223be 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: 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 8155fcb56b69..17f9b88c6002 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 069befa91216..e1c5a22967e0 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) {} | ^^^^ 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 89017f6cc3ec..9047fa4f3fee 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 492e06fbbc06..833df51a7aac 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 7c06fe3400ee..5b76ab56e245 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 dfdf078e3035..ec3e2e96231f 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 { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `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 3d2b0402bc52..0366c2f44c0e 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 20109d4d1166..317c04d2c747 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(ty: T, ty1: U) -> impl Future + 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 d0605d7e1a6f..14ef1cbb67c5 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 443af010c4a1..8739c22a3104 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: 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 4a1705715cac..313f6079c7c1 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 80c1fdf002a8..3fd60223542b 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 4c9741f6f37a..584b71ce643f 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 53487aaca998..baa41c2e8222 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 4bb466ff16c5..6c3aac5ed3ba 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 0b5343a98cfb..9fafdb1ed391 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 6bdb9ded4827..c2dfa050fc2e 100644 --- a/tests/ui/async-await/issue-74047.stderr +++ b/tests/ui/async-await/issue-74047.stderr @@ -7,6 +7,6 @@ LL | impl TryFrom for MyStream {} = help: implement the missing item: `type Error = /* Type */;` = help: implement the missing item: `fn try_from(_: OtherStream) -> Result>::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 4427014ae3bf..1bdd6423e78f 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` 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 b69033a0eda0..c7316b971f5a 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 64b378f83fc0..6c3ca750e0ee 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 d5a3f72cf251..0398e57ef780 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 cd8450568051..19c70e8743a1 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 c5fd5c5bf0a0..d1d80ce038ce 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::().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 5926a4f3995a..c44ad583d923 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 19cc339ec0a0..3fa5c738c011 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 6dd3726608ba..ba256b19948c 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 203b17550a0b..59c6a4e493af 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) { | +++ -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 9c2f20df6576..80a831cc5475 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 88542315ec00..f7f285ad0ccd 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 b8741333c328..19512116a66c 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 e2a73539874e..3fb504a0e3ad 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 2a712aee9c48..90c1e976dcee 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 679272858bde..cd93f8a3c559 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 c1a4b467f104..dc373a24f6f5 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 b6583022c161..91a9e5aa6cab 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 90ec646c8c09..29095f3c4d2a 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 4eaed1cf155e..ddc9bde59adf 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`, 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 d750df9918ee..61b492fe9895 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`, 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 12c15bf56ce2..7adccdba2f87 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 1f589c516a90..d26595536990 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 310a29239557..f088b118730a 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: 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 61126faf8992..9c1ad32cc2ce 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::

` (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 fe88e08c1234..1a313a86f7cc 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 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 80522b6eee52..96377d8d0364 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 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 1f9bef40c4e7..d19d3fa0ff7f 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 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 6d7f4844a993..4a0c8d7fdc3f 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 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 49e7ab6082c8..d34f257c8d91 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 d72e47e9ed8f..3b0ffae86965 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 923fae400a91..17ce01fd59bb 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 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 ad97741dae4d..8ff99ddbe218 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 bed6a2ce4882..c86606f33527 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 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 2b0308fd661c..4392fb16deb4 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 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 3585355ab77f..7a030d454604 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 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 5ff124e48dca..3351ceaf2f01 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 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 1f55c1f250a3..14d85c5263e0 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 b211e2f8ed8a..35a712aad8a1 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 1ae8d9128b1f..14ee169bdaa2 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 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 b448c35e8462..56f8309a69f9 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 bb1622628dc1..e5265b67eaba 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 3b879fdfc6bb..94cb74047c85 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 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 76e65d239f87..8e117422a796 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 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 be2f567155c3..3cb4aad003f4 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 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 ca533d8505cf..eab024dde662 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 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 8ddc3043e966..c025be4f6365 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 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 97b6cbca4124..6e42be3954d1 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 6bce5b823f38..0cad260a14a4 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 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 a1c73e555ef7..ca1f54145689 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 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 fdc1c8553476..500c752e20d0 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 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 6deb4a46cd53..a808a9463a04 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 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 e3c3756fd21c..4555ef1874f3 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 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 d47a76a50efb..c12b3ba517d1 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 { = note: see issue #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 2ef6a1c04042..4c7ae9e2ef5e 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 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 2b213acebb50..ca21f222588d 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 ae010fdf3f84..74b9e4bc4c86 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() {} | ^ -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 8430a9ec6a75..e525c95ac36b 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 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 3993357006f4..bb808961eb21 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 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 8af0eedc82b1..a53337139776 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 01c8ee30c5f5..f727fdae90ec 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:, {} = note: see issue #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 a5ec3599f6a1..86f6040b14ff 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 0526c6dc8398..fe9a88b5ebbc 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 MyMarker for T {} LL | impl 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 8686aed8f829..b2e2a7c8cc11 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 006915389388..f8fa8c54198b 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 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 18e6503c5524..cc6506c5680e 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 9ffaaa8de7a0..d72249e02129 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 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 3999a6d2d2f8..657802632b05 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 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 a549cb64e0cb..b33721ca43d9 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 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 48493b786d64..869764fa4569 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 6e0e0b2703a3..fa30d461f9c1 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 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 eec9d1a29248..157bf18c9e87 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 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 57ffaed78f5e..4ff85dc0797e 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 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 6352e908708a..8fbbfb59a482 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 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 3978d4111bb0..305186e51173 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 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 41cd6dbd8bc0..919a97673fb0 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 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 65c8fe052290..13ea3603a8da 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 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 022409f95566..028dff34c9d3 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 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 d747aea6d177..2c78e4e38320 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 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 cf3284467f77..6fbade424b8e 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 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 39afbf2db7e5..fc9bcd90e52e 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 9aeeb88cf04f..f1595e034be5 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 bea6cee0a89e..dd5a1cd89e7f 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 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 d4c201b5d3ec..ba076568088b 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 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 218e0292776d..0053d9d5cff8 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 314238a34df8..5f9e5d440fb2 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 1a8536d37d6f..7419af80a323 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 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 e5c05872dbf8..0a731ddcc0b6 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 0c30c9dc50c0..b8cbc296370d 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 aa1e5aff6525..70068fa3aadc 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 bb6a14d88b3d..950dea721e29 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 8d61950d8c2a..090ca9353a7f 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 4c0ac52865d7..c0650ff17c5e 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 459432bf4e42..66147ae45faf 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 d41644faa282..690ccb8d08b0 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 c5b0b11e7d09..986e805d4f99 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 ee7d8a5cc237..f325a3ce2931 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 ddeb769eadc5..62ca8862d21b 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 dbd5aef458b8..beab3db0d94c 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 2482d632695c..41ea4df72a2f 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 65140a0794f8..47aa02c09af2 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 13ebfd1e2033..6917bea65915 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 03e3d545a991..5a2f92250e02 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 0c3df04eabcd..e57b5af82cde 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 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 4df639232a33..3be630e2b235 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 3f6401b9f7a4..4662eb32abb7 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 d417f2883936..c2a8fa741ca5 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 219029e2afd6..06254775b74d 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 32ee2e1d2073..4417f2326654 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 b656b76bfe4e..bd102e581356 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 067ee824d5d8..6c6a313c4df7 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 959a7c43fff7..475cf8c88749 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 b330d1076476..bd49dc472445 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 a2396a8fbb16..bb6558739ba7 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 cdb211555274..00822324039f 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 9bf8056e82ec..194a2fa08cea 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 49a82a6769dc..2082603d2fb7 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 c93a3b9b25c1..393becd1b345 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 b1b38f6b9194..3add3ae2eeb2 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::::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 b9a53cbd4fcb..c8d39afdeb95 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 df1a23a19edd..43edcbde35c6 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 d4a9ca3e7c66..564ee1466876 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 4fb2f8c659c5..fea2ab61e929 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 258a8d163936..7497e48c5d24 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 c7c0846595d5..af716916548a 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 6b312202bfed..45634131ad31 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 45cdd3d2ddca..16808f29daca 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`, 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 0b8af90b4186..692d98bc53c8 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 a8fb100a7496..161fe82e3739 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 abad0f25c0f4..685c2794967b 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 ::Bar<()>: 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/generic-associated-types/bugs/hrtb-implied-1.stderr b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr index 362aeae23614..5dfc42bc8735 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 1ee270398de4..9a1a09b29df9 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 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 c67e02437cd8..77f363ee87db 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 ebe2054ce5ef..b80e3e798bd4 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 | ^ 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 5e94db9b0c00..e16312dbb275 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 `::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 fe2abdedbf37..31ed47749a87 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 a9a70bb7130c..624fe2799e06 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: 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 b9e2c4186c14..74418a0c0bd5 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(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 56857c6550bd..ba87ac9185d3 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 | ^ 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 1045e80f046f..b4ca65889ada 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 = ::fmap::(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 3c3ae24dd473..db1deab92b83 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 `<>::Family as CollectionFamily>::Member` = 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 a085096e1f8c..0c395a1664f0 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 = ()> + '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 fdedd3bf5fbf..78992112a7c5 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 = 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 3b65b32f45d9..54dbe28bd033 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 `::Y` to `Vec` LL | fn f = Vec>>(a: T::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/generic-associated-types/cross-crate-bounds.stderr b/tests/ui/generic-associated-types/cross-crate-bounds.stderr index 83ee04d5a6c6..ebd733c2ef1f 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 b753181cf480..1ac35b318fd8 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 614c4a34c187..84210eeb1a62 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 LendingIterator = A>>(iter: T) -> Self LL | fn from_iter LendingIterator = 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 f6b0b644e406..717d867057e7 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 LendingIterator = A>>(iter: T) -> Self LL | fn from_iter LendingIterator = 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 7ea7a7b2de7b..8ae308303b8a 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 9013d4295300..bd3728cec8c8 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 -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 91967fb85097..9c3753c2d180 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(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 6e7a0b1f67f7..69ae5676ee02 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 = Wrapper; | ^ 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 6e7a0b1f67f7..69ae5676ee02 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 = Wrapper; | ^ 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 7a7900a1e656..39ca7954edef 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 = ()>; | ^^^^^^^^ 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 7006744df498..da0924312f16 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; LL | type Assoc3 = Vec 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 4cc68530ee1a..f39d00554282 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 6bb7492af811..55901cf450b6 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 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 2376bda8190d..6bf832bb9e2a 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> 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 2429531e4e5a..d9f26ee6c291 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> 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 11221353a92d..3dc9ff10243f 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> 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 52300efc2d8c..45fb65f6cf1e 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> 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 0514e7bd6f69..d71ad870d3c4 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 20c07db4c04f..ecb337bbceb9 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> 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 E0271`. diff --git a/tests/ui/generic-associated-types/issue-71176.stderr b/tests/ui/generic-associated-types/issue-71176.stderr index 4b4fe43e8c4f..ed837f347533 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 = 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 b93ee37987f2..4bc13d7b2894 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 59b85abf5c8c..e50e3df85b36 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 = [u8]>>(t: Box) -> &'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 369b86d29284..f6fe8b16902b 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 = 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 1d8a3d410f8d..a5d56256d283 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=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 6e0d2ff4ded4..4076e951875e 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 = MOuter::Wrapped>, | +++ -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 16287323995d..a8b63f150797 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 = 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 4f4f96a4b921..488fbeceddd1 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 = &'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 e0fc225f463a..5eb988ea042a 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 = 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 df30be65ec54..730dc8fffe85 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>; | ++++ -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 eae9bd9b16f2..01f2a92f94a6 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 0ee665f38ad0..73f984dcfb86 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 a44bb6993d49..c85b72fbfe11 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 c259c89a712e..44f871e71c57 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 d77076a28fab..79ac6d0f10bd 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 + ?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 ad40ee180019..64cd55e684c6 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 2b1a25acfa43..ab75a9240060 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 b86e2a204b04..e4bcc92bf6e0 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 d04788a919aa..ed0b2085c885 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 0d49398cac94..2bb9d0c7ba60 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 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 d5db962094ce..ac636ebb648c 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 ddc420a7b4e6..5dfd66d544a3 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 91a06d5acde1..b9a16cf184e4 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 eb15cbc620ac..752bb32926cd 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 = 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 4246f8c069d4..7ca0b2912a68 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 = 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 91a030076408..ee90f61aabc7 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 378115f6d389..1f142f7f6c12 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 = /* 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 8a71fc73a9d2..d0eb27343a96 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 41945aabfb58..ac0960864076 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 _: ::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 72a987b4a1d5..57bff7c9e054 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; | ^^^^ 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 4a0566ca7b51..7c34a0acdbe0 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; | ^^^^ 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 53d5f9de6575..59c21e24a42d 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>) {} | | | 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 aae9a56bb612..1b3b264e7508 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 ` 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 b1b8afeecd02..6f5eee9928ce 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 `::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 556422c272cf..e3cfd46524ea 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 45b64d2b0248..9f9418e20b9d 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 64aa8adf8a76..e7e905427960 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 = 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 930080f7c378..1475d988ea48 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 62da45e55d6b..598622869454 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: Option = None::; | ^^^^^^ -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 2b57713b5c10..34553c51654b 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 c3ef94529a49..942e5dbd88ef 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 a68400798d81..b8438a0589c5 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 bed213b0caa7..f522190e8aa3 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 c90215b612d4..4d9f6fedef14 100644 --- a/tests/ui/generics/generic-extern.stderr +++ b/tests/ui/generics/generic-extern.stderr @@ -6,6 +6,6 @@ LL | fn foo(); | = 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 88594129caab..00e62843cb4b 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::

() = 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 262561fa81e6..11227328e1b9 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::::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 2f4682c4e5a9..c5812abfd3df 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( | ^^^ - -------- -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 4ae5098a121f..6974c8ad0457 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>(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 6450bbd8b432..6f79b09f6cd3 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; | +++ -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 4d01ba1f453d..c44f6b7ddc02 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( | ^^^ - -------- -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 fa661c274ebc..d7a6faa19410 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, 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 1c510044f806..7d4fdb2d8791 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() { | ----^^--^^----- 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 fd23b6276f92..aeaf0187eb51 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() { | ----^^--^^----- 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 6791182238c7..3f4f50562e25 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 {} | ^^^^^^^^^^^^^^^^^ 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 c5584962dc9e..67fed200f969 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 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 70793a9c9208..d7e12f07e060 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(&'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 93affaffe60c..0c5a65f0c3d8 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(&'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 acbc1300d00f..cf40e857d42b 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 Struct where ::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 559527663e8a..0d856d096aff 100644 --- a/tests/ui/generics/issue-95208.stderr +++ b/tests/ui/generics/issue-95208.stderr @@ -6,5 +6,5 @@ LL | impl Struct 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 0736d94106e7..2b09d43960f6 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: `` -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 ab09ebcae719..3d2a26e33c36 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); = 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 96f07e190c1e..d61562bb199f 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, | = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #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 83ef522ab46e..9811d30cf6a8 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 6ce56ba4b7ce..357d3a4a124d 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 ee5b0e11c66f..b44a69525a65 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 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 cb7f998df7a5..8dfc46069f13 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 43e7f03b8b4e..a7dd41397923 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 ec3472a50368..eca5c3301801 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 c1948ab62714..2381b8ecb969 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 de2591329c88..5cf188702dab 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 497c7d1216cd..a52f956d063a 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 890dac16e94e..d0892fd8b095 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 b7264c7e933f..7cb7edfafeb6 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 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 2355979b0f95..c6adbd91e786 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` = 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 269cde54c7e3..a8e00125fc63 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 5241b475d5ca..c6d6f5083282 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 520938a63351..916854e07afb 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::(&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 8ab88c580755..77aa37cefe36 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 139c844d8a22..67417a5e525c 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 f014eab8601f..7f81ee331bf6 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 70d5b3c2ec58..10904515fd8f 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 db5fc4bf1bae..f269babcf71a 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 364b613fc771..9697a270b8aa 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 fn(&'b u32)>` = note: ...but it actually implements `Trait`, 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 cb2ce8a4116a..cf64c2acdbe9 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 fn(Cell<&'b u32>)>` = note: ...but it actually implements `Trait)>`, 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 b1b8ffa8c548..e10da26665eb 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 25af011e3fc4..b1081c073ef0 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 3f874220a270..c50e79dd4cc4 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::(); = 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 0f051be2128b..99d088799fbd 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 d4bc5b67220a..6155579c9fa8 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 7b0743cc7c5c..64707642eeb0 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(>::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 55eaef78634c..075e422e29c0 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> >::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 081dbb67df85..a2ec96f1a2d0 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 LL | for<'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 714178375f2d..0d8d652b6f33 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 7369e77d0709..1abc739fc362 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 46314cdd5ab4..a5d509fab996 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 f8840c8f85a3..4abd14f93558 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 4f1419de4267..c0fd3f4b7ebf 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 64d27e064870..a3ae5042f0bc 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 9d091cedd237..701986ea76e7 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 fb90825c0d93..a2dd83d560fe 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 932c951e7a54..5f334fd89603 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 deb6a205994a..5529d8dc8365 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 f23e741debe9..77a77c8472f6 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 cf7f78a99e81..495afc69a954 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 1c93da02f614..b9f447e15122 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 3c0ffeb10575..e7128f83e110 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 32ba3741a59e..35f2750403de 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 f108617fba61..230ad052db3e 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 690bcd03226f..6921ed29e207 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 1d11cd0f5713..44d11cfbafa9 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 b22f3e75b6f4..7b124edf6f6d 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 edd05916ede2..a9764cea49e5 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 0375ed56d966..1c2f9ff5405f 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 70a24304dda3..c677c8812886 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 f303534c709f..016ee8f71f98 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 89613bd5c202..b5ca62f4e23d 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` instead of `&dyn Iterator) -> 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 7a5c0612c07e..4f214a12747e 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 762698c4fc14..2ef35a377e2f 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 18e4c618dba9..4df7ffb29ba6 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 74631a037860..cbc6eee5a3fc 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 168a5aa18ec4..825682c52f9f 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 cabba4bafafd..b87e31acc125 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>) -> 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 baeec6d5892d..6c9b8cf24273 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 d5086c7bc515..158cfc8347c5 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]) -> 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 7833ac688bab..3f979d1a50b3 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 AnotherTrait for T {} LL | impl AnotherTrait for D { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `D` -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 7833ac688bab..3f979d1a50b3 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 AnotherTrait for T {} LL | impl AnotherTrait for D { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `D` -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 28643ec03e17..3fab766fa235 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) {} | ^^^^ 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 7c69c4bfe97b..faaad2769271 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 for Foo { - impl Into for T where U: From; -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 a1a629bddbde..06b5ae6e3b01 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 750687e23222..cfc13298071a 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 9b63911da7aa..ea3d7f324a58 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 9c1011018704..e8cd16bc3016 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(_f: impl AsRef) {} | ^^^ - = 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 a26460c8ecc3..b2478c4cd295 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 728bcc0aa865..622997072873 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 4ac3c238fe95..4f8121ae879e 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:: | +++++ -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 edf3911e2a09..6e36922b4696 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 { | ^^^^^^^^^^^^^^^^^^^ 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 30fbba168689..2e13ca753fc2 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 { | +++ -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 835f7f765600..4e453c108d4b 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 db97fc2bdc46..7046e729e183 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(&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 7cfbe3447b81..4380f47c5de4 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 af60da07cac3..d5b543ea953d 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) -> >::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 7c9028a8cd53..79a86b0a3aed 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 `::{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 324eaa37a3d2..c898d17f4b70 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<'_>> + '_ { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -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 1570b2ecd535..86f9cc4d9926 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); | ^^^^ 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 a658d8fa0781..8ec30239ea8d 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 fcace10cd014..77f6945f064c 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 596ff1011555..6f1ac4bce43b 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 cd45c6a9c6d4..baee1b5db6e9 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 830e663da376..39f70e413571 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 f29ec95d5940..9cc4c4b2f9e5 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; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 043dbc8db5d0..d847065ebc2a 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(&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 872988faf7ab..1f25069a0169 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` 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 874a1b95a431..59ffea6fb9f0 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 e0bd1cc4f194..f8980828b89e 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 096e96c85c4b..a6fb1a200e69 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 96eff1a5815e..0b26e039e6b2 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 0fc847051c97..9226e1f8b983 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 1fd678a1f3ac..3e763c9f1df2 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 e260762d89f5..4996e6839e96 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 181d6a284daa..db587d069f8b 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(self) -> impl Foo; | ^^^^^^ 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 afc59cc5b580..5ace64b69035 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 7e1a8f083acc..3430055dab17 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 6e4a5bb5df36..73ada8d70961 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>; | ^^^^^^^ 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 729963a8141e..b8ac826adaa9 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 468cf12f1bc0..0cd76815afa7 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> { | | | ...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 cec94e39a35f..cf68ed87030a 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 2836e9c7821e..eed4c07710e0 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() -> 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 61a0f8454d13..4c5a42c0b4b4 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 d2dbd8c62054..b3b696775070 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) -> 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 267ecfdaed12..759634892369 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: &'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 e87a9d28ae1f..83410dfc6ea9 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 e87a9d28ae1f..83410dfc6ea9 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 5eb2dd9184be..cef4449dbb98 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 84add5799aba..ba02d2898e9b 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 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 aa9a61cb592d..4024c5afa80b 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 {} | ^^^^ 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 b542b6141996..9af0fad9cdb9 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() -> 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 cb370fbe1c41..4ff8527bbe9d 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 90d6904ed616..e330d178d4ea 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 173fca63fa01..9567e09651d6 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 c86e9eadc87c..06e85e521d22 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 9150d957db76..e5d718393738 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 { | ^^^^^^^^^^^^ -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 9a8e3675b956..946ad74b8722 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 = 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 67cabf449506..c4ab79f110dd 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 7d22f027a6da..999ffd521415 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 6bebbc01f3d6..83d0d7765724 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>>) { } | | 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 e31393181d73..55f47785f0ee 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>::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 8d3d4b5e2061..0e105817b18a 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>) { } | | 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 49376f559cfc..e67e48728ed0 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;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 d3ea8cb0377c..17cfa151a686 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 ee140e6f6c43..274139f01d08 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 5609f8b9b012..fcc67291e4d2 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 0adcd4a7a2f5..b87084433120 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 d39dcf7fbf5d..200257235fea 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 b4be16ff0420..d03e458aeb82 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>| 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 20b131b8bd20..963865efa69f 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 6d3be3fff0e1..3ad18a13290a 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 3fe4ee73c80c..e9a635f244bc 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> = 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 2ab1e6a03124..8513cb2881e1 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 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 7a4cc57b0881..6cf1a42d6a99 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 86d7184da7a4..88fb1fb27070 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(data: &[T]) -> impl Iterator> { | +++ -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 f0dceb1b11a5..a83e0df911b0 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; | ^^^^^^^^^^^^ 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 b727b2ca0cce..c401269da83c 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 f3c090408b42..faa5d3ba4489 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::(); | ^^^^^^^^^^^^^ -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 5b0b1cc5e426..b968592beffd 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 01d9f506a0c5..00709ee7438a 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 68ac22a05f4d..4d4ba58c9744 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 493a9e66eaf8..060eaa7e64a1 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 ddce5e7ece2b..3cb4be16fc3f 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 { | = 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 a1e2d227ff38..14d51a1b0642 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 { | ++++ -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 71d1d45f48bd..0fcacc19ca3a 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 3a636f2524ff..a58fa5cd7115 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 ada8fd7fa50e..e0513433b8ec 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 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 2347805343c9..5ade6a69d4b0 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> { | = 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 a4ff510477a4..c4ea44740662 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 Test for T where T: Super {} | ^^^^ ^ ---------- 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 45911b7fc11f..e838634ed087 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 { 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 45911b7fc11f..e838634ed087 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 { 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 b98b859a99bf..bc810c0f88f3 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 e4556bc21a7f..43f0eeeb5583 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 608c94fc0723..7fe275f06fbe 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 c10a856d83ba..b0ae10b8d862 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 e5f7e5e5c449..b60529ed0029 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 e3a4797e44cb..e49d1d18b0cf 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 451ba407b718..1dccfd17a709 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 30322f88cca4..d3d651a28e13 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 46859296fb8b..28dfcd8b871d 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(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 4df7f45c3b37..be37da08e76f 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 82e0f23964f7..21da1d087acf 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 ab8a53d0db39..3b4844ab1333 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 b5a091b61faf..e0718927976a 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 b3765ac1a541..c421e587a9ef 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 { 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 c7ad1b4e608f..ef61fa4be483 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 e0a968527205..e9357113f364 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 307899297bc0..92284df41c74 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 88abd5f54c2a..07cb0aecda8e 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 ebe07027d2fa..86b12cf8fa29 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 43d3e058ffeb..a89645c128bf 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 ac9f7ab25296..49f2fcd0a677 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(f: F) -> Result<(), io::Error> LL | F: FnOnce(&mut UIView) -> 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 9e0188694ed9..0b736317980c 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 898e5e9511e7..abffee57a0f0 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 6076eea3c75f..df83fce3bdef 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 765d6afa8d7e..5b7f3059ef42 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 2c6b56c61fd4..addc28ff52a3 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 32056fba69f9..11914efe9d87 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 82f5eb83e6f2..73bb73e34906 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 1b9a2e4720d5..982da0c913ed 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 dca2b4ebee7b..ab4aeacbd998 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 f1f1dfbdbdbf..41a8772d28fa 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 4254bfb5efb5..4020ec1b579d 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 820ff1bb536d..6a2837e770dc 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 86bbea579ae2..2eb268813d0f 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 1abfcde03dfb..1a95200a6622 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 b87bfb1be52c..8ad2d6be4d27 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 a6a5b1393dae..bdc0e85b43ed 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 23f8d57645d1..070186f2bf2f 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 3c26907d3d06..9786eb52d354 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 da888979c30f..55eea66fd3b0 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 ca75c9c18bd2..80b0a7f06199 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 e0b478f1aec4..c99e83851187 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 6cc1221cfe99..b7f1f69dc8f0 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 8d9a3aee9802..1b95fcf55679 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 70f91bd3c5bf..9daa73a9fe6b 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 1f50debb07b1..a77f399e7918 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 019ef9ad56a1..840608ca2a14 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 7f5e47aa84fb..8256f96c62dd 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 1afaf622be7d..4eda57dd9e5e 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 428634828f9b..15622f233fa5 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 4c5875ba7766..de9bdc4f2cc8 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 430cc0fda26d..332561eca7a3 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 2e1b468603d4..e9b632d2718c 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 4d5b392a7e10..e63399d554ee 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 25aca4cb7ec2..80cea1a83d93 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 656b011bc3be..b19d5d8f7589 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 e9a9d47ce7cd..627a09a07b86 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 98fd8a623fea..8f2f7bbac0c9 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 2c4e8ce996b1..ae26d1fd0bbc 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 209ae2201f99..46560ef9244e 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 dfb5810c494c..9b0a2534a1d1 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 5a63af588554..5751f41ae9d1 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 2d26b08384e1..69e084db6ffc 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 ed185ae2a446..f1ee5112dc16 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 53968a2960cc..be42a4a5b1d8 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 05fe111b38bc..6bcba1ad429c 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 c38166ddea6a..ae8edb049564 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 67d4114149a4..a409265525b4 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 5374ba3dc9e6..f1ae78452417 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 88cc42ccf668..c8473cc85bda 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 e2dfe02bc853..c2a321250118 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 810d41009c52..6c75b45d926c 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 ab44f067fe74..ea350e97e642 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 b6f5c726a5ca..d58d2798746c 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 0ef762e1c823..536f51dcb3b2 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 8e226804890d..597ecdce9eb9 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 490dccd3e808..a82a4101ce0b 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 e57b88e50c63..81fe1294671d 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 fd7e99165b55..8a83e5813836 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 5133273c22f6..41772b8e694d 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 81b7ea791912..a43e92b14580 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 08128d794251..a76c3c87a470 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 bf231c92cad0..dca57f3d5b63 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 2cb212a01396..4ec28ddf8717 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` -error: aborting due to 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 80f2bd52314d..6affb1ed9625 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 3e2fbc2ab6f2..4cced22789f7 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` 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 9cbe221de139..0674deb63ba0 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 | >>::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 0579cf238a9d..346109fd5c01 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 98639f307fbf..e3cf0cca8371 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 a4b818e6e2bb..507a70c1bac4 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 888c321bc479..ff4d7418a63a 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 dc43abf52c65..b908c7142d4b 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 a1c4cd851cb9..2301eacc596d 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 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 2819329275d1..afece960914d 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, 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 045a5aa7bf0e..27cc7a33238e 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 47229a5fee14..442e7479a9eb 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 * >::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 af8714f1c808..673649c767e3 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 22c0f113d6ab..391d3e7613e0 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 % >::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 e89e4dca6191..af8b310fd1d9 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::(&"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 80c0c8abec6a..ab62db8e6af2 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> = >> as Access>::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 97ed53fb3ce5..00de4029e428 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 4f621b82dc57..fe3cee771609 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::()); //<- Do not suggest `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/inference/issue-86162-2.stderr b/tests/ui/inference/issue-86162-2.stderr index 9aff2cec160f..7b45b196629e 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::()); //<- Do not suggest `Foo::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/inference/multiple-impl-apply.stderr b/tests/ui/inference/multiple-impl-apply.stderr index ec49e15201af..1a81955e1e88 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 6b86753caf99..7b400fd17db4 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 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 2ad35ab039f4..fcac537a9b84 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::; | ^^^^^^^^^^^^^^^^^ 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 68ecb3813483..dfbdc3266c56 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::(); | +++++ -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 cbc2477deb39..c72529f71c2a 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 397d8e7be04f..333c93859b57 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::(); | +++++ -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 36d75469392b..aeebf68e6757 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 _ = (::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 84f0475d8cda..ed389393abc9 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::; | +++++ -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 464655bbcf45..3de317d2af6d 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 9ca94cd58df3..455304524edc 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 04b521dbdb36..d651927788ea 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::(); | +++++ -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 6161690df505..535c0044aec0 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 52baa213302c..45303a2c87ff 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::>()? | ++++++++++ -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 9d9265f8c367..3862c1139c5c 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>); | ++++ + -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 951e0f5870d7..43d267fa46bf 100644 --- a/tests/ui/infinite/infinite-instantiation.stderr +++ b/tests/ui/infinite/infinite-instantiation.stderr @@ -11,5 +11,5 @@ LL | fn function(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 15654dfaf88f..08fb4fa77236 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 53b603a47b55..fd5a3c3c5464 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 513bbfc1b8cf..4ca408260b84 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), 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 39d7aa4c16aa..220d81031ac2 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 ec63688fa8b9..57ca1b24d2a3 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 3a146215905a..3aac0d7d1db7 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; | = 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 e47d9b652fb4..efafc9b75cdb 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 00b716cd2596..5876a6c9e198 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::() }]; | = 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 443fcf89c4e1..75877bc093a7 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 1bec41e2efa0..ebd18f89d9c9 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 c971e8afb357..45f850d1f99b 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 6f7408f4e2a6..a46d73950458 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 c94782b17ce9..02c4a60b68f2 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 795fc8f5921a..7f06b97818bf 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 d6948e7acc03..cd86020184dd 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 1b176579bbbc..255f6bc6a195 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 6e3b0c8a380b..119094bfc4c7 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 f77c265a2ada..1caa6042fd20 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 0c3be7ca6077..36686565e2e3 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 5110b9be08a5..8f519fe6b5f2 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 5c63992d8198..ed9196d2b63b 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 558e3dbb78df..7c07c762827d 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 65b507b887b4..335b9877aa00 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 c42498390c78..4b29b4c1b6a9 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 c42498390c78..4b29b4c1b6a9 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 52a591902646..7bc17c5c68c2 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 ae1f85e41e41..bbacf3f46cfb 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 08aec25928c0..a8f65883d636 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 37753e61f582..bf7160bcd2d3 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 ff2217b5e80b..7abb56602d4b 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 b9887af962cb..c9d0a338ef42 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 c196d4278a27..1cf77d4086bb 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 c8a4d6813792..1df345325337 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 dbe025b7330b..f85adc10cac0 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 4600034952b3..b1c80438b318 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 a14ab7d85e85..31528ab856e6 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 4072a2fa1624..a5563720f622 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 f1d9ed8ac8b7..5775a4032c39 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 a7b827d27a87..68ed9a0de5d5 100644 --- a/tests/ui/issues/issue-10291.stderr +++ b/tests/ui/issues/issue-10291.stderr @@ -7,5 +7,5 @@ LL | drop:: 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 c0766480a41f..0e2761f3f57b 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 1b7b9d5909eb..c6bc0786af1e 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 f1da33eaba1c..9aa042171748 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 2e4365f1ed76..61828f9c02a6 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 4d8a85a13971..f3bd0100a72a 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 fc1548013405..a8a18c49549d 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 879dc5b76c59..275a0e6b5d77 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 aa9768b1885a..8262bc9321ac 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 f2f930766719..4f23ba86eecc 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 386463436b8e..46382f652184 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 84746ca2c889..53add509ca56 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 9afd209773b7..9ff66eaef498 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>` 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 8d6b81c24b68..3d7fb13d4475 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 | >::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 b9ffa499afe0..51061c0262eb 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`, 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 2e585867941d..2a6233547ee8 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 d2a6a96082e5..93dc1df8f634 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 ac75ebb4256d..e9ba52ff4fde 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 9c29a37cb930..95d4a704e72d 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 8368978deab1..7cc2860eb508 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 139c34c8880a..28c459e6e62c 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 ccab95878b52..87a6782a5e6c 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 3eb05f504c23..6226c580811c 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 8ad921027e2e..e2ba1150d07b 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 4b1d979da36e..236e6b48607f 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 babbb6e519bc..6f6fdff66788 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 ded927693b20..1c1855ce94de 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 f8375d4ef901..ac8947670592 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 0a9640a9e317..83879583b1f2 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 3a43627e6910..0de7b902fe05 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) {} | +++ -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 5c07066018e8..4f89ae51157b 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 df61aabf00a7..e7bf555c1b70 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 203dd92c9fb0..a6f1daefe636 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 b80c68ce4731..370e64779012 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 f07bc7ad4f18..c71b0363eef6 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 670bd546335f..e30dbfd205b8 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 2adcf55eca97..25dd1e3374db 100644 --- a/tests/ui/issues/issue-14853.stderr +++ b/tests/ui/issues/issue-14853.stderr @@ -7,6 +7,6 @@ LL | fn yay(_: Option, thing: &[T]); LL | fn yay(_:Option, 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 6e63269293b7..279f5772d21d 100644 --- a/tests/ui/issues/issue-14915.stderr +++ b/tests/ui/issues/issue-14915.stderr @@ -6,6 +6,6 @@ LL | println!("{}", x + 1); | | | Box -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 f142e260a231..587a5c85e924 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 b7c950892dc2..8e0fc8f17709 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 25ce7cb5cc06..a1047e27ba22 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 085958411ccb..03a0100f1bdc 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 d9bdc69ad717..af50fe467d17 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 598ec7e6053b..7ed2e1991303 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 ec0d74596aa8..381f6dc22760 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 fe06810b8dff..14727e74334c 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 bb809840b2aa..9ffd0e7e6453 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 5eb5e0864ad1..9d3e88114616 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 0f08485e515d..e24b9bfa3c04 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 02f9f3ea8fdf..6af920ca4397 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 3fe7507e8a41..efbd7f712a45 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 Collection for Col { | ^ 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 fff681b2e0b7..39b22ed1f156 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 5f6eae73e585..a4a406b3d4ba 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 6db29bc61b12..229ff9f18177 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: 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 c53707c5d696..0ed12d3a2e97 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 d7e6069977b4..6ea32e0a45c3 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 3419c0798595..0b42274223a0 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 32e20d77465a..d89848604575 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 55e51e566d98..8fbf6882699d 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 5c429d1113df..9438f5c6345d 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 37274e239ba0..47f5bf4dc330 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 3a8f569a3a5c..68f54a310844 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 = 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 b37811e19559..0c95a3c0c40d 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::::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 613ef6b907c5..7a7d2374ef87 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 baab675834fc..2a15af50d02a 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 62b7b79538c6..102c8537f8e0 100644 --- a/tests/ui/issues/issue-17904-2.stderr +++ b/tests/ui/issues/issue-17904-2.stderr @@ -6,6 +6,6 @@ LL | struct Foo 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 33534d3f8f6a..42a7e0442073 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 3e3706bcb7de..bba7e725b124 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 fb795febf795..604413c4b6d1 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 { | ^^^^^^^^^^^^^^^^^^^ -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 61e1e496f795..ba3def64dfb5 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 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 18159ffc2384..c880bb002919 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 cf4e06316a71..702207c30f7c 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 5e0589eed435..5de13a5c314c 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 a7dc64708d85..11015d75d973 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); | ^^^ 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 5d154dbbbdd6..2c6015eaa9d4 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 602b80c6824f..d84c490df4dc 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 4c224eb2d243..059c7f137819 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 8db78935f839..e8ec48b0d269 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 784b9b984e90..ab2374586e4e 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 40098f9622fa..b2cf0bad1df6 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 */, /* &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 b0b03a0eea69..6dcd891cedac 100644 --- a/tests/ui/issues/issue-18919.stderr +++ b/tests/ui/issues/issue-18919.stderr @@ -18,6 +18,6 @@ LL | enum Option { LL | Some(T), | - ...if indirection were used here: `Box` -error: aborting due to 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 b9e27873636c..76082dadd374 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 ce413662f0da..31fd46c8e2a5 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() { } | ^^^ `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 90d0bb406554..03b9249bb1e3 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 a546924253c2..b7c7da006723 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() 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 1083b011252e..844cb0ff1999 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() 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 3f0787c88757..525ca4685bb7 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() 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 3358cac82e06..9c1336402e64 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 71655457f901..533861b1114e 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 90e6f7995605..903a9f98c758 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` -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 13a12acb3605..f451dc36d45f 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 4c32a4cf3dd5..db235d473038 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 9e888ed758a1..1e3d7a2e2f51 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 81757974de9d..ed48714fe507 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 826b2ac049b0..0355d3a89710 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 57b0882b636e..ff039f3adba9 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 ebdf2528fe1f..8f45f0d36c71 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 9ac751e4dc43..6738708ca225 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 7a0b344a5aa2..f740b0cca06c 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 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 3ae952546a62..2dd0b3c2f843 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 a3447aa6845b..f537a01582b6 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 0c7e728c67e8..81f80aef5944 100644 --- a/tests/ui/issues/issue-20772.stderr +++ b/tests/ui/issues/issue-20772.stderr @@ -12,6 +12,6 @@ LL | trait T : Iterator | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = 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 c3af1f6786b3..bd3ff5d59c62 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 as Publisher<'_>>` found ` 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 3819a21a2cff..00357155c8a9 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 b39a3aad3719..892a4530ebcb 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 5981d9dc7330..a6b75c913524 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: `>::A` (this type does not have a fixed size) = note: target type: `>::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 8b749edcc77f..9f66f43a195a 100644 --- a/tests/ui/issues/issue-21177.stderr +++ b/tests/ui/issues/issue-21177.stderr @@ -12,6 +12,6 @@ LL | fn 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/issues/issue-21202.stderr b/tests/ui/issues/issue-21202.stderr index e7c3f2f9a071..3485994e8f42 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 82549288064a..96e0f5fdb31d 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 { Ok(7) } = note: expected signature `fn(&mut S) -> Option` found signature `fn(&mut S) -> Result` -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 ecaf6faba429..cd1059d48993 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 26874faa2b93..a9268646edfc 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 c75038b6169c..b130f162414d 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 6ea552a26a5c..b1b59af6ec2b 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 a336d1b0ed55..8a7fca5f4364 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 a887635d3546..3d623985cbb3 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() {} | ^^^^ 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 3d3852664999..f19893926880 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 Trait2 for 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-21946.stderr b/tests/ui/issues/issue-21946.stderr index 67f6b3081bb3..d1b4a808d2ec 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 `::A == _` LL | type A = ::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 2d60b18b1f20..3934846ea028 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 d64b024098c9..6d899618d7a9 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 b594e8b7a1ee..560fbc73bbdc 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 da15c092fc31..be3f5ace5480 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>::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 cd27c4e4e4ed..977cfe06bb8b 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 dab62bcbb4d2..172ae386c3e4 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` -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 fb2b9b42859f..052888d2029b 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 2b34830d0842..b599f6febe31 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 1caa4221f250..a372078abd84 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(&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 2407ece5e4f7..e2ca54caeac0 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 5366a36b1a68..309e11a25f1a 100644 --- a/tests/ui/issues/issue-22706.stderr +++ b/tests/ui/issues/issue-22706.stderr @@ -6,6 +6,6 @@ LL | fn is_copy::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 c2391a7c0911..47a1ef8cc027 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 63222d25c017..6ff710b11332 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

(process: P) where P: Process<'static>,

>::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 d64899080444..717ce72b9c14 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 c4b396559241..a04fa677f9ec 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 1a0e87e15d6b..8cda8598f3c4 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 4271c67c3bcf..0142926dd156 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:: _>(); | ~~~~~~~~~~~~~~ -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 1403ecbd92d4..b6e23814543f 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 3a9f49ef167d..6a61df8d46b2 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 = <::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 0b568b30e08d..c432a502c134 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 ` as Next>::Next == LL | type Next = 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 af77e4b1a412..b8aa587a7398 100644 --- a/tests/ui/issues/issue-23122-2.stderr +++ b/tests/ui/issues/issue-23122-2.stderr @@ -13,6 +13,6 @@ LL | impl Next for GetNext { | | | 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 ed065212c560..37d778dc992e 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 5d3d8a4f808a..05ee0474c783 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 44f01c1c1673..ec7696909e72 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 804334c9b0d2..e1f4e8a96c82 100644 --- a/tests/ui/issues/issue-23281.stderr +++ b/tests/ui/issues/issue-23281.stderr @@ -18,6 +18,6 @@ LL | struct Vec { LL | t: T, | - ...if indirection were used here: `Box` -error: aborting due to 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 d753bdeb9f70..5c2758dc6090 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 b756ee1d5e25..93665af69dd8 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 6cdc94551fe4..b3e933a21718 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 ebb70afe3168..d917a4c51d59 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: 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 c912baccb492..2a7e93f0eb71 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: 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 542aed0eb261..c29e88614442 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 72102f460e0b..37a86ecc5437 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 954fd4928126..b260d0273885 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 f1c3891b8700..015569cce06b 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 b9e15f5e21ba..08a5a8ac56e1 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 50d7f988e194..d42750e7a2b5 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 8b4f1dbce431..8ec34aa13fa6 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) { | ^^^ -------------------- -error: aborting due to 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 065bf7def42f..2acfe70b4854 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>(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 e6ed3aac7103..23f1441e69dc 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:: }); | +++++ -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 727b96908291..720b77866a58 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 6aacd563af16..517b4814eaea 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`, 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 1427e43854f5..673f29fff18c 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 2c873243fe9e..f1f553adf0f6 100644 --- a/tests/ui/issues/issue-26056.stderr +++ b/tests/ui/issues/issue-26056.stderr @@ -12,6 +12,6 @@ LL | trait Map: MapLookup<::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 73c772205c3d..0b153ad7490e 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() 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 91d28a5e1e1e..d15e5753a25e 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 1282fd7d3c23..9175bd2a3032 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 fd1bbb9c5673..c2a3d4b83d53 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) {} | ^^^^^^^ 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 10dbb7325859..86f6a14cd105 100644 --- a/tests/ui/issues/issue-26905.stderr +++ b/tests/ui/issues/issue-26905.stderr @@ -7,6 +7,6 @@ LL | impl, U: ?Sized> CoerceUnsized> for MyRc{ = 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` to `NotPhantomData`) -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 faede1687673..982c9758a3bc 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 9d18045aa794..b4bfaa278633 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 ced92bbd4848..d0ba9f6ae2b1 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 9caaffd9c9a2..3353b83f4e56 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 da751a649573..aba8e612858a 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 b5a2b2f55a6d..5cd3f080450d 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 71ed7d70b5b8..873f7efcd73f 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 9027098d2d1a..ef5cdb42e610 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 960259080f73..c8db0403e59a 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 d19c4af2df7c..33f40a341c8f 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 7ee0cd486707..3600622a4542 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` (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 1d470fb5e0f0..e7b7ba082688 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 e3562810b3aa..63172b85424d 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 2eb8a1c2653c..8fd3c7ffc303 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 d0d9485310b4..a9cda55fd9ac 100644 --- a/tests/ui/issues/issue-29147.stderr +++ b/tests/ui/issues/issue-29147.stderr @@ -12,6 +12,6 @@ LL | impl Foo for S5 { fn xxx(&self) {} } LL | impl Foo for S5 { 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 538bbe2f5029..134808b4d236 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 d9d3cf360df2..e7860c19eaa4 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 0d09612c6c2c..f4a08e1751fc 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 87e770e1543d..f303221cf8aa 100644 --- a/tests/ui/issues/issue-30007.stderr +++ b/tests/ui/issues/issue-30007.stderr @@ -9,5 +9,5 @@ LL | let i: Vec; | = 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 a00a1dbb8843..cf71a01b58a5 100644 --- a/tests/ui/issues/issue-30123.stderr +++ b/tests/ui/issues/issue-30123.stderr @@ -7,6 +7,6 @@ LL | let ug = Graph::::new_undirected(); = note: the function or associated item was found for - `issue_30123_aux::Graph` -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 72289c5f9c34..48777fec0a3f 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 64cbd58d6954..0f69f49f505a 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 4b88547a1aff..6f97a189cead 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 4971e3357b4b..9785d56f4fcb 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 cb2991809dd1..177b78754cc3 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 da2af83ff03c..3106aaddc4a1 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 2603c944207d..6ef84d7daef5 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 b4f5b1296670..ae5dffe1fadf 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 02c335c1547f..eb4327bef625 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 dc51198d98ce..1989a915cc14 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), | ++++ + -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 5e870eb3e8d1..01a81cea1eca 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` (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 a6c55ba03fca..477c01f68640 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 c8450f400429..5badaa153f2b 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 e849f5d0490d..eac8f10fcc16 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 { 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 a831cf585f4e..f3e1ca08b6fc 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 f770ded50d0f..97b1230ce350 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 f9a25b69ff62..41bc60d03dd8 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 69ef876d2550..e6aa0d25934c 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 8e9a16619f3b..6a6188f10c8f 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) 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 0f0821518a42..c6906734b2de 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 fd5f7dcf6e66..2a4d6d2449ed 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 79e889b7e599..875af7048322 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 84c7a9efa35b..0be0e93c19e6 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 4a2c15511fe2..6f6602793fdb 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 197e80ac097c..f23b55689e3e 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 b31d2a31551e..169e3d05d23b 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 55988844c178..4a674b010ea6 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]>), | ++++ + -error: aborting due to 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 5b753c69d5d1..522fb36e1434 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 ba9651041543..3676f388891e 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 edc49979c10a..d761b2d87db4 100644 --- a/tests/ui/issues/issue-3668.stderr +++ b/tests/ui/issues/issue-3668.stderr @@ -6,6 +6,6 @@ LL | static childVal: Box

= 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 0b0ae419e2bf..2a757b44dc83 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 418194fac992..e5c943c7c3d8 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 Foo for 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/issues/issue-3702-2.stderr b/tests/ui/issues/issue-3702-2.stderr index 0b94c3135a10..4edca796f43e 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 87832dd29b28..ccee9ed4daad 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 1e1f451b450a..2c404b4e7447 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 a0dbcc920fa3..d4f4b79102d5 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> | ++++ + -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 7ddb36c8e6f7..633abeb6f226 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 610696f84d5f..ed8b6b60afc0 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 c04a01118a44..fbf88d503397 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 f9ab8a515071..4a4bd2ee43d8 100644 --- a/tests/ui/issues/issue-38919.stderr +++ b/tests/ui/issues/issue-38919.stderr @@ -6,6 +6,6 @@ LL | fn foo() { 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 ab15bb1afa82..4dd83ddf32d3 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 3a1476ac0e3a..1bc11dab327a 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 cd2a014bb683..15c9a80bb352 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 b1b3041ea027..f4742115a199 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 | ::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 f98fde437848..a6c6c61f1709 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 deecf7a9d752..cf839a131406 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 713bc404f670..0fe73574bad6 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 db5d064379a7..180adcd6e99b 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 e15eed656123..7976d0905420 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 1bc554efb5c3..987558903ee4 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 e88f31ea1ee1..81fed1305cbe 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 eb077415e6ce..43e8a73b8194 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 b4e302dfffc7..1bd1c4dd57d7 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 afc39adec467..f7770e00013c 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 9b6469d05e92..dec9af4b6d1c 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 97492e6e0fa2..d7b35245d8f5 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 31fdf3b72e7a..afc2cac7343f 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 62307d387c82..55be59684b55 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 1618f0f5a11a..a5a2fab2ede0 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 7c87fde540d1..fe7d4df70676 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>` = help: to modify a `HashMap>`, 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 61a0ae5fa91a..47c7e5dc11ff 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 6414e26929a4..9d09be66305b 100644 --- a/tests/ui/issues/issue-41880.stderr +++ b/tests/ui/issues/issue-41880.stderr @@ -7,6 +7,6 @@ LL | pub struct Iterate { LL | println!("{:?}", a.iter().take(10).collect::>()); | ^^^^ 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 d5a9d233bc96..d5919870d9be 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 8c7303f3c3c5..48b1c762e19a 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 12047e22f1b0..41f6cc97e49b 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 f2971df5db27..670b98c77089 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 bec14429d38f..f174f42b2398 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 ecc1fa523989..8b4aff54dc3c 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 9aeca8efe4a6..25179ef6a96c 100644 --- a/tests/ui/issues/issue-43355.stderr +++ b/tests/ui/issues/issue-43355.stderr @@ -9,6 +9,6 @@ LL | impl Trait1> for A { | = note: downstream crates may implement trait `Trait2>` 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 9b141e2bf99a..3da8cc7288d3 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 8f59d7cc3aa7..64a3c2a3d8d0 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); | ^^^^ -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 4edb528699d4..6d47ba271624 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 | 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 b0ad25063de8..7cc347c6163b 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 f67f91a6bd3d..7c5c50a38a93 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 9e97012416a9..8554154fba51 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 daf67219f4d0..3e12de34e11e 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 2a245c92c486..633fb177b75d 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 1fd69f6e7779..26d2b385efa2 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 78ee336f19a4..5d544ee10a90 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 be259d3f8a49..6fae86f9f31c 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 e651e2a68d16..5a10c429564c 100644 --- a/tests/ui/issues/issue-45801.stderr +++ b/tests/ui/issues/issue-45801.stderr @@ -7,6 +7,6 @@ LL | req.get_ref::(); = help: the trait `Plugin` 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 f3eaa91769f6..95a39b1d1980 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 6e126038cc95..e87c17b2ad36 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 d72d6477db64..86a3602899ab 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 890ef8014b48..8c0c1dfa6ee8 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 c1fad44b885f..aff2d77a0c85 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 2ae6e709d5ad..d45172239820 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 6e561e03a8b7..6115da28cc91 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 512827b2dbdc..fab55fbfd704 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 38a219bbd7b5..f47df306ab84 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 c2c7df7a333a..d25c6eda9c34 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 2a1f1819c33c..146dd1d57ce3 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 4f0fd948e760..12e5c15d77fc 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 b04ac5536c41..4fca0296e437 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 7143fb4d6e14..0d3b77b46084 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 3f2e1b83ad57..74bfa1e06933 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 0bb46724f616..6b4247f1d796 100644 --- a/tests/ui/issues/issue-48728.stderr +++ b/tests/ui/issues/issue-48728.stderr @@ -10,6 +10,6 @@ LL | impl 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 159199a7fcec..504ea3e80103 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 e544e4244034..25f299ae5f3b 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 1ce0333846f4..549e5509474d 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 83daded7e093..8de3909ca305 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 14beadececb9..1c77090de27b 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 8098be5cc458..597d76fc27b3 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 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 ce8173169b1b..84247a427048 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 943f7748696b..bf05ab5665cb 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 a3b9ac677580..ac744a6d3b67 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 aa771e4c04e8..688d2cf3486e 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 d50befa5e326..193d815d5195 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 f69963bb7af6..fe47790f1ddf 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 07b6df072cb4..bac1ade3b0c8 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 d285c3467ab4..e3ae7f144c35 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 1ac5dde66e9e..1a3514fb715d 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 3191bd3de32f..0839ece79aaf 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::); } | +++++ -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 df7603d79747..873f179f56d9 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 bacd09b2ae11..7593ac383469 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 a11aceb6211c..57f9769d1dd5 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 e185ecdda238..beaea1e634ce 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 e064fabccd04..e1b5ae325120 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 5e196bd4e25a..c02c0ac93fa0 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 c07f8735eb2c..4839a0d46095 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 5ae8e067807f..b7451ea28ee9 100644 --- a/tests/ui/issues/issue-51154.stderr +++ b/tests/ui/issues/issue-51154.stderr @@ -14,6 +14,6 @@ LL | let _: Box = 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 93aaf4b9d823..53c140b5b6d1 100644 --- a/tests/ui/issues/issue-5153.stderr +++ b/tests/ui/issues/issue-5153.stderr @@ -7,6 +7,6 @@ LL | fn foo(self: Box); 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 c92da53dbc48..99fce1eeea6f 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 b39159a65390..5be3695dd454 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 0812976cf409..1d8e136f217b 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 316e755f42aa..af9553e5cf38 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 ef41f078b803..ce8e6fe2bf8d 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`, 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 f53ddb95416d..63c2dbfc55cd 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 842ebd196983..442902bd1c3f 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 c764736d7987..8b56b36d39b7 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 468cdf2dcf92..ab8c37225cae 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 2fedef7d23dd..293465ecb814 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 {} | ^^^^^^^ 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 e4cdb7e889bc..38fa98e65e13 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 b28fbff62b90..61a1aedf5082 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::::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 059462a363e8..1bb946ce4cb5 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` 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 5361ee1d3455..75eef543f272 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 a91e4b31f4bd..6d1d74e30455 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 516c59afb33e..97e5990750e3 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 faf78cfe8d9f..eec6426a2995 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 97fd6678c997..2c38041642d3 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 f164fd0c5d24..f3d4c2fef94e 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); = 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: Rc`, `self: Arc`, or `self: Pin

` (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 c394e620b82f..60a2e92dc71b 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 391e69c91fb0..10cbb34ef5de 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), | -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 b10273f14bd0..79b1b131afa2 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 37beb587d276..57477f5341ed 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 0323a4dfb8ad..40435fd0f0a9 100644 --- a/tests/ui/issues/issue-57924.stderr +++ b/tests/ui/issues/issue-57924.stderr @@ -6,6 +6,6 @@ LL | Self::(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 6134d6889ff6..4434f5a0ff25 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 310a2b593fe8..6074f7d0ed4e 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 d2314626d3e8..5ae1ec7cac8f 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 a3e2531b5caa..51d9708e0fa4 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 6aef35f0bb96..ac70bc725e27 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 Conj{} | ^ -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 e9a4bf96741e..960de1be299e 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(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 d07258ea7a2f..c0b3cd6de66d 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: `` -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 83229e02c6ca..670a54894b5c 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: `` -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 ae3c4d12025e..b9317621b77a 100644 --- a/tests/ui/issues/issue-60218.stderr +++ b/tests/ui/issues/issue-60218.stderr @@ -20,6 +20,6 @@ LL | pub fn trigger_error(iterable: I, functor: F) LL | for<'t> ::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 aa922e2682d8..f825141fa062 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 dd87b62664b5..d018986efece 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`'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 bedea3890a32..be6e28edfc24 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 f6d7968c0c40..8750fbcf4cf7 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 b6b1f3a66c78..1c8e020e9cbb 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 386ac794d7db..0cab37553406 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`'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 2ec151d24d1c..7fc414602d28 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 e234e6da552a..70e85b584bd2 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 7ccab8894837..c959658c0ce2 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 4af3672ef72b..d4266814a7c4 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 2b96a0fb5e55..fe104bfe4454 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 4fa73a464fbb..e6281eb54270 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 6fde44eaf0ce..1ea2d48b474d 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` = note: required for `Pin` to implement `PartialEq>>` -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 f97d899c2d3f..9c25c0fd9a14 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 Foo { | +++++++++++++++++++++ -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 f93ed67dab24..539bd45dbf1a 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 96b8e656991c..298a1cf9e0d5 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 2ad67ec23be8..9d1fb3a10ddd 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 a209f8a4249f..4fca2ff39fed 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 { self } = note: expected struct `Box` 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 e35379fd1cfe..e2e574867461 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 918163b60947..cd7921f550e5 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 80fb4aed1cd6..6ed318c8768b 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 b942cf75b06a..a08704c90732 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 `::S` to `()` or calling a method that returns `::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 a9bf2bf763d5..1fb6ab14e644 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 c4b6f90ca69a..35be632f5797 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 4b8b979665cc..c2c15ca10ce2 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 7449fe697ae9..7371e2105de8 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>` --> $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 5cd64e48ab88..a31d29de1d5d 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 da3800affc05..240d9716a556 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 c983026995b2..db4c8f25dbc4 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 197ca8d5a7b2..4c510e91ada4 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 58c1c18f9a9b..dfed0b6e67e3 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 eda635646dfa..e98e69314d91 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 70daf8a2f1a6..985d6dde9f2a 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 | ::A:: {} | ~~~~~~~~~~~~~~~~~ -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 4fb1af344cda..1a0cf5da8be5 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 b8b0eb310cf3..80504c070a3c 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 b04a0eef3713..1e6bb92ea579 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 38e46683b082..20494f319ddd 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 d57f1b778df1..eb97916ad75e 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 dade9e469503..672bf69a7325 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 e02cd7fcfa9e..d81bc3615575 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) {} | ++++++++ -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 22332b357231..9af598fe43f5 100644 --- a/tests/ui/issues/issue-8727.stderr +++ b/tests/ui/issues/issue-8727.stderr @@ -22,5 +22,5 @@ LL | fn generic() { | ^^^^^^^^^^^^^^^ = 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 f359dd638ad9..5a4ec55833be 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 91d99f393b61..66141628e28d 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 e49eac3babf8..2f6e2687d24c 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 bd9e7df4991b..d647edaf37e2 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 4fd9f3030fc5..e99d8e5cc80a 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| 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 cc7ded498fc2..e5ed19f3731c 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); | ^^^^^^^^ 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 e38745cc10e1..38e5de803ccf 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 bae23a1f8ff8..c3cb00c3c684 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 e728fec29102..f68c596367e5 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::(); 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 a7d9c481a1a6..e2a80dbffdea 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::>(); `[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 030af0c5ada6..a18bceaa6cf1 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 8bb89d2ee215..7cc4a95ac149 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 9bf416341e8c..f9def6fd831f 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 20ecf6bac764..50cac77c1b07 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 6dcfa3a48116..b8f0901bc307 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 060e7c3eafc2..098ef8d82a04 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 1f64f3b73d6c..bfb27c143ff7 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 0e0d67cb97b1..bf595442c3b8 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 86f6e00064f7..0f7a8a7e7ea8 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 1d26ae51f44a..a51232090adb 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(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 077004ae7616..8bb784d1d496 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) { } | ^^^^ 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 dc1bb6206afc..860a9391bbb0 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() { } | ^^^^ 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 3143729f99bb..c5ad9ff2a085 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 f5d903f38eb9..e5a8a143d030 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 c6e811a94fe2..b492904bcc73 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 f7516c7d377d..08e679a7c559 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 35783a1be78a..0187f965b5c0 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(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 83764a91ac78..bb53d336bb29 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 66d4397a2935..cd7361255eb9 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(_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 53d776cd846a..1a5905ab8e60 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(_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 7d002e090b5a..c61ace3cd628 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(_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 91994b9d7429..ef943d6b3dba 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(_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 25570f960537..00395a05d33f 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(_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 87940d05e785..193f25bab05b 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(_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 5363871e2022..56b787d2ae38 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() -> 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 14bfcc3d04d9..aa1b1b73baef 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(_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 f873f7614bdc..98814dcd24a7 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(_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 280d423bd7e1..e0a8496dba99 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(_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 4e4f8a5cdb39..4437b0fdcfb1 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(_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 085d4b1f238e..8570d96fc621 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 ff55a1365e45..bb0583dfde05 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(_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 cf7423fc16fe..28ea61f38a3e 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 de58a014ee8f..1b8f1c3fd6fa 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> = >::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 ee2c5ab7e39c..d17564a1ecae 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 cbb8d6af38ad..ad4f0cda19e5 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 } | ^^^^^^^ 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 5cc854adce0d..71309788dac8 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 97ab59c398a3..433c6b38d0b4 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(Box>); | +++ -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 0b206f31e7b6..9e9376227751 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 3b216ac1581f..fdc5bae15379 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 = Option; | ^^^^ 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 3b216ac1581f..fdc5bae15379 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 = Option; | ^^^^ 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 8ddf0ce6c655..6b0613787e8b 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; | -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 193f80b23d3c..baf4215bbf78 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; | ^^^^^^^ 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 d022f8251407..bd8095224a72 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 = ::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 57e525917307..12948e956cac 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 6a015aced6f4..1ff5000e7a3d 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 05b8a9169fb7..2cad1be8c463 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 023fab8fe4a3..e4d6534c5153 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 = &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 dd1365a9ef07..0f854493b7e4 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 c63fd61c5dec..c8058ec66924 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 941e588b1768..05668a23138e 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 3b4f0982940e..335ee3dfb1ea 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 064025e0345b..73c357dd5d46 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 470a11d4769b..eda0025afa5e 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 c2b19a7ad5f2..1518a37ab53f 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 fec4421c48a7..1a1dd85e606e 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 43c43721b19f..6ce309ca2055 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 06dc0f2b537b..6173a4b1d51f 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 c513fafeeb35..ea65bffd1036 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 3653e76c9cbd..9117b689c94e 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 621196647644..cca7f52957e4 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 42aa393667dc..cd66eb5e3fea 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 87dbb64abd1a..310ddb21647f 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 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 808d8bb90588..24bb9e2ef7d6 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, Box); | ++++ ++++ ++++ -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 c235c31809fb..9bc2263ab3dd 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 535073d6ebb0..fb1c7cf7ad35 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 3d4208031cd0..0877f1548a84 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 f7bdee6336e2..d99ea6a0c309 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) {} | ^^^^^^^^^^^^^^ 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 6ccf008c003e..f7293ed809c3 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<'_>; | ++++ -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 421ab3fcf4eb..1664466df3cb 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 63d00875dd33..af22078aff59 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 64aa8361cd5e..e202c31214d3 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 b40481ecdc40..5518ded0106d 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 194fd95891eb..c689fa9884a7 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 64f4bd0fc706..3da50cfbb1d0 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 961f9de6614a..6dda9e61a79c 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 5bb763813322..5827b2fe695a 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 29a70695710f..1df0776a51b5 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 6fd7f67d15ea..da454b8fd863 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 2687266e0986..a1dfff883a00 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 bcc3e9510ac9..62b0a8a04bf7 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 90d4754ebab8..25a2f4b96f40 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, y: &mut Vec>) { 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 a03e16b3b791..e2725977d837 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 487b34e3d18f..1025581d5acf 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>, y: Ref) { 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 1622ce422905..df1d03d51703 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>, 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/ex2c-push-inference-variable.stderr b/tests/ui/lifetimes/lifetime-errors/ex2c-push-inference-variable.stderr index 99fab4631a21..cace80272f5b 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 52c5752f6ea1..4a981e4de604 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 e90c81ee3e1a..2bd047113bca 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 5a23f1e0e9d9..30083b5ef546 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 4c0ffe5c0901..4f1cb1e79722 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 97c665347f6e..3a1947973b55 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 b3d0bc2b882f..352619c0ffc3 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 fbe98a4263ec..16cf009ee48b 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 9630729d0ee6..c778f77366ab 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, 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 1e24032fc1ce..080eb43cecbc 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 79e7e8e157d9..60ca41684551 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 53615fd1aba6..98e490c3827b 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 6ff441167375..ea1cc1f18a4d 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 9ff5e42d732c..e934ce7c040e 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 e4c855e11fe2..dde271d100c5 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 9661f1e5144b..420cfa6b569b 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 ec9fac0c288e..875d22576e58 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 9c61d5a0c25e..917d204367ff 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 32dd896932d2..fb93b7855a4c 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 c35d8ecec5e2..554bcb5451fc 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 79df2c8dfbcc..a491de8ac1e3 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 4399045098d0..3f457da1b474 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 5791b6439c93..8d395c3c6a95 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 24adb33b0889..2ebaf17a138c 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 5e2bda9be504..fcd40607af46 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` 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 ce14bc5b8886..782db20c7f34 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>>` are too big for the current archi LL | let fat: Option>>> = 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 167272890aaa..d1f0cc39c188 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 0d21a42883eb..893730cbbd26 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 6b463930b007..97ca0f4fb592 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 44b2be269494..7b9b8f76d0c8 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 d5991bcf5693..06aad9616cb7 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 aabdd14b69b7..a0f6bff66760 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 33187cfdbb63..0748d94189c6 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 06a070822630..2448c160c5c0 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 e0be1ac2117b..fcaaa39b6744 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 7265f711fd01..49290d5a13fb 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 dbb5880ab92f..5f7b7ef227c8 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 30d4d2b7bbab..f76655b3c725 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 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 cd042179cce7..04a0f56c1633 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 3f3affe5a981..05b16b44c534 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 01ca08a6f19b..c5d72707f80e 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 | ::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 d1c66a81cd8a..d8c75c33b0c5 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 f034cfa9338a..1ba42e9ce323 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 59d8429ea696..d78f198e7321 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 486d32a9f08c..7b527e7b8b46 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 7d068cead44b..9f7d25502e73 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 119ce11e34a1..a0f5962dfe02 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 6391f0941c86..a6bf2e1f436c 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 e35e13a9ec6d..1c7d6d945976 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 446447d974a8..87c858fdb2a2 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 6344a70ea3ae..2e43a67d5c83 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 d26dd3aff954..bd7b41256603 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 6029bf268560..0ae15fde47b0 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 7adcf884886e..f466a616580c 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 bb4e928ad158..327e6e3e956f 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 42beed10c19f..b3a3741d245f 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 fd425e5f74e6..bbea56ac64ae 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 728d51f34a49..1f3d40605f67 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 7b43f0b2ca8f..4704e9ef8355 100644 --- a/tests/ui/lint/issue-106991.stderr +++ b/tests/ui/lint/issue-106991.stderr @@ -6,6 +6,6 @@ LL | fn bar() -> impl Iterator { | = note: required for `Map>, for<'a> fn(&'a mut Vec) {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 7db9e71a584b..a175964ccf63 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 9b5453fa82d4..f4305f37fe01 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 cc44f8aa58bd..f78bf899b848 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 c1b56250d3ed..4cb79f7fd292 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 3a46ce7e1952..0005e55324f7 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 fb58af0a42f8..f88a1df55e06 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 583579140966..7922d1c084da 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 49fa54114b21..ef30a406969d 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 c41ce666db87..e5607ba72e97 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 98245c4f144a..fcb106c485d8 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 b4eb921b97e2..a3b3ebaac303 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 e44cd45bd30f..40a9cd00c50f 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 f59fb3cc750d..746304694167 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 ba425ceb442b..52d9c8471e56 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 1bc0e41fd550..eccfa19fda78 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 e5f5ce20d1c9..37c9192d2a49 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 4b42145bbed8..f3207226cd93 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 da6b89c1e049..1136b707d595 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 d4fe26a43c2e..8be7365cfc34 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 c8b997c87070..f21f9a934f3f 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 411ff51aad74..54c951b1f63e 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 98d8d1dd27f3..a5ac540d1254 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 970e6b838ada..3d4337bbc6f9 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 90a06bc6cbe5..2448a64f11d9 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 029334c2eb67..849c9ec5ca0f 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 6b76ad3b578c..fd63433c3086 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 dc0515b84820..6d3629ba388f 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 46f6a10de274..8bc8530b4224 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 675443ddedf5..d6bb72f34dce 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 984254571452..a1aa85e6744e 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 51bdf84a321b..3df0c4281679 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 3bbb60dd3592..3a2af452ce20 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 383623b48317..0b1289742758 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 eb65a9e98c6e..90b2af7dea9b 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 838b3bc13fee..7aa21f2560c2 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 b3420ad8afde..91363350884e 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 db46e7ae7148..77487164a136 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 76f95481605f..5ac56499c1f2 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 2d289404ded7..5f441ef4a664 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 a2abfffc170b..6170a36a8139 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 5d5b04a5d959..2876e1cf6750 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 ab20a8be8747..9ec33b1c4903 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 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 9b5fc37a3329..ca53a753150e 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 41c8896921b0..e6c36b789510 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 ed91a4a0bc62..aa772afc7a96 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 fdada85eb4d1..5a73064c7877 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 294476107ef7..3adf26cfee22 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 11c95c1464ae..716369d8e6a5 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 e8d696477ada..9efc187833f0 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 ba9e18bcce5c..7f5d1792bf12 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 e926719bb6be..9eaf71129338 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 b5601cf9e659..b8e7d61a1ecc 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 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 4852c3313969..0e445d2439b4 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 096e867aa16d..8491a4327564 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 94a95c1d8fda..9945c78e8ba6 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 a347458097fa..29719b2dad52 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 f07aa2012df5..b41f14d82ebf 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 b299e99a3a90..c815045df88f 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 6f4d97068b35..44e4fb582b5c 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 95b7938ae038..3e8298c6b72e 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 8234ed3b1678..b69ac3d97fd2 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 5f66c0315817..dcda1e5306f9 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 797c867103f0..76b2a0556393 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 6edf0a2cf8d5..f027e169b42b 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 5eced4f06c0c..a8a41e081294 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 20aeedcc2412..d4fa96c10a28 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 cb45add9c2b1..c7ccf30ea24e 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 ac3b2b5b21a7..4bdfee9159b2 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 adbf27fcca2f..ef4089f31f43 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 dce03a0f738b..3babc94b4eb6 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 66cdce7dacf8..f0174560fd58 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 5db9539cbf1e..578a40e4070d 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 bb7e7e27a4ca..2f55b50f0baf 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 80458a70a010..8eb71cd99bfc 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 07b2ef6cd1bc..b5d48f4985ea 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 ddbdbdb0fd04..a5adadca26ee 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 2adc2d43809b..216469bf6abb 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 afdb733cd030..8fe999e02e3a 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 479a086a80c3..f4252e1ac33c 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 d14cd6cb4e03..9697ed5cb114 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 a060914f1785..7180eb23bf5e 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 4dff7447dd76..dc48c4cc9acf 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 3accba197a13..eab51edca37f 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 65d55ca8f707..2323451a7d2d 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 e6a60d7bc407..5a5e9c4f0bbe 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 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 605a1841cf37..946057d05439 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 972e2d341ec0..c933e0d0cd8e 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 c2c5c84cded5..c1cbd544afde 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 a57c784ff6fc..6ee77fb47af3 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 f9d94b6810cb..bcd6eb353e52 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 1d1ae60cda17..c9f27a6a672c 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 8eec8b37c85e..4d52f6c0f3d7 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 f66afa94f4da..7e421845258a 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 dd0fdf3a12ab..c3d7960de564 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 cb046d0b0aca..8e4a514c7c6b 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 e54fcf068d8e..a1958cc436ad 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 d67f3c33d36e..85f5994c7204 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 f609c4943ef2..27853161e4f3 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 a52fc5e3da6a..c5f8b9abc19a 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 e0a4f3878d8b..e0f6d5b2de00 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 58accea27bb9..887a4fbbdc8e 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 80eecf8f1b97..e99109e11729 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 89a6f585ce41..89c634ce4f0b 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 034e3731b87f..1971a6bd12e4 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 e898af7faa30..ae59102684d5 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 d125cff63eab..a335786df864 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 64280219d759..a7249981648c 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 af509aa59d48..95af07d82d8f 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 17014c6ceeeb..dd09da6df4f4 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 ecdf48470f73..0b614e3e5f8c 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 f83e192130bd..9c33e4e8427a 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 f2065689f444..6f06df3861db 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 62e7dff54769..c94662c2d7f8 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 3886a70bb15c..33cafd93a404 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 = 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 e06873b50265..ea926e0103ad 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 396a91994eb5..d5a8a117f9a3 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 bbbca211b8d1..fb2c103139b9 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 b1f0896f3b65..4e796333748c 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 5a2af45d077c..7c7cb26b4071 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 7ab3685c5cbf..f20d67329dbe 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 53a0a0793b26..b75e4a9c9e06 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 1935de02b57a..0a083ec1d9ce 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 1ef70f87a1fb..9c404aeb429e 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 29ccd17e0699..d9042adfc375 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 e266617bd224..c395e0c9100d 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 5359f68cd551..4259815328b3 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 3316d3872648..bbcaaba66e51 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 b4e2883e8371..9e65cc3dcd62 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 1eca0186da95..10b78d6eb39f 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 d0312c485082..1813a2ec792b 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 3f492b141a5f..2eee63f307af 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 77b6486155cd..b6e10f45e381 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 7ef1fcbbce3e..e6b39dfef858 100644 --- a/tests/ui/macros/macro-interpolation.stderr +++ b/tests/ui/macros/macro-interpolation.stderr @@ -12,5 +12,5 @@ LL | let _: qpath!(ty, ::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 b04734482655..919111ede51d 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 0f412bc86fb3..e93bd11046d0 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 e7c37c8ddbeb..1fe714aa7aad 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 2aa1e58f6b15..1089f67f4336 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 -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 d7c8aaae22e1..9059b10faaac 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 e1ed87f94355..9ff3d741c01d 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 0418e6116041..87c0655a422d 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 24e3e89ea9bf..247750a8ad70 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 9574b7a1e25f..87646031cdb8 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 f1c3512bc9b8..485d7b7869a9 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 81c6722b56a8..642d9e84874b 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 4a864c2e9271..e719c397ff21 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 4e5482a518c9..6d2f159a5740 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 c958104eac43..364f3da6e15a 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 85b86e2211f2..adbf5274e68e 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 36339542ac61..89345866be80 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 00d954d24f38..e25ff57e57f3 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 4ab16bd10173..cc3efacbc541 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 adf64b089350..0c8c4850bfa7 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 fad150cadfca..49b5053a023c 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 88c2c1c773d3..499f9a7637d2 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 7e1f2dcad11c..bf4704285c0d 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 dedefac5c464..8795f7d4345b 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 ec036e8b1e24..44689853dabc 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 e57347b362dd..9ad2bc73a4ff 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 d70ef31eed65..ddaa2b9c1efe 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 2cc2e134bfdf..6a133d5e4064 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 7060f5d8b479..447f5dcf8644 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 3d64b0a67a1d..9486a9405628 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 1e5f368758e6..d07fc09064f2 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 89e0d982eafd..ad90aeda1d13 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 04f7ebe019ea..99f709eadb73 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 de045d56c9cc..38d2302a48d2 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 133bc0484ee0..cdad382d11cf 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() { } | ^^^^^^ 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 64bccda56c65..daee4e66ad10 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 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 5ebac8270ddf..5e58f5227ed6 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 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 fc44205e81e6..8280547af43d 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 f4dc910c34a6..b0af50f8599c 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 0dafeae870ef..3a311eb00ccb 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 12f37274b6b2..e91063de8e08 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 d0e50f3ae16b..eb9f4ba1ad69 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 686fbd0baa3c..6cbdf03d4c27 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 5078f03d6017..9d6bb5d1dcd2 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 27a82c1242cc..4feb1bef9ad5 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 a0a3697266d4..65ac1bae3449 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 ba32d0e99a47..12b143dd29b9 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 c994ee4f6d4f..cde7ac972ca8 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 b353d3514feb..b9878a195324 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 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 bb0fcdb99905..27968239a8e5 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 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 fdc6fd77077e..b8abeab158ba 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 aac873c760e7..c9446d164337 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 25e8152d8cf5..fb4ec2664613 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 e3b501b2fd55..44571ac5326f 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 5247bea62ceb..bdfe063d5bbd 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 e6d93b8b5f57..5a6c9dff7579 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, shouldwe2: Option) -> 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 ec3b76e3f4d5..15dc672c1fd9 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 4adeebe2a591..d5b7603d346d 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 87330155eacc..4221dd04cfaa 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 07c8101cbc68..b3d4dfe5aaa8 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 b0217a7c844d..1603c0026bed 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 d6be29cf582c..ae7446d48335 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 5132d92777bd..0c775612bfbf 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 9a84768a9f4a..690f979fa37d 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 313591433918..8be6d6d64f7e 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 5bb887b4503a..333520847f83 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 | ::foo(); LL | ::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 df01966b3a2c..9da307436e9b 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 95c9d7ebac02..73f6043f256e 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 | ::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 25ad360b329a..c72e7e0cdc37 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 = 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 4b93082ace57..54d855d340ea 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::(); | ^^^^^^ 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 dd616c4a5e75..f0b111379894 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 5102a452f0c2..9746c404013d 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 7c454a9a777c..070d912d1294 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 | ::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 9694f80ab6d0..86c2f6431d1b 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 b429ad3046e9..105274ee7d0e 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 3d18c249afe2..4b9cdc4f9379 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 9b18b3427adf..62c9e55a44bb 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 = 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 a7b66fe10ce7..167400170419 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, string: &'a str) { LL | let Foo(ref mut y): Foo = 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 925dc258a4c3..1f04d119b566 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 2f6524d03e00..30635148dae6 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 Result { | ~~~~~~~~~~~~~~~~~~~ -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 64e59e6c4482..bd37f0c92ad8 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 6c1a9dc03173..3bf056d152cf 100644 --- a/tests/ui/mir/issue-92893.stderr +++ b/tests/ui/mir/issue-92893.stderr @@ -6,5 +6,5 @@ LL | struct Bug { | = 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 66a85c4656af..6609fa8c0711 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 d7db90e50e51..801e8a0ff1d0 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 8a146d784e29..798c4e00aa7b 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 7be94ef4ad66..9d4852cff8c6 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 f36fe64bffb9..f75244790182 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 96ab3a029914..2f33628a4916 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 a883aba35bfb..b93ce4a8674c 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 db2c1189e1e1..4886fa30e89b 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 ca819d93a50a..e769ed0c1f97 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 881ff909722f..62f83ce706fa 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 a5f38dd53666..c54a62c5e6f7 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::::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 88416ba4bb6d..5c2278ddfc6a 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>; | ^^^^ 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 a662741afcd9..38146cef3475 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 9dab3e522557..be3a3e2abf14 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 252e56387ba8..2166de85f1fe 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 88d625456564..51b5f3b1af2f 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 4bbeaaab9375..e95467add38c 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 3e44fb759296..a7a35ec27740 100644 --- a/tests/ui/mismatched_types/similar_paths.stderr +++ b/tests/ui/mismatched_types/similar_paths.stderr @@ -15,6 +15,6 @@ note: `Option` is defined in the current crate LL | 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/mismatched_types/similar_paths_primitive.stderr b/tests/ui/mismatched_types/similar_paths_primitive.stderr index 80e78a4e4fa3..c9881891319d 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 5c4c13266d03..3db9803d58f7 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 80aef7fcbe8e..aaa3a9f191ad 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) { | ^ ----------------------- -error: aborting due to 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 54b220065274..a900a49c7105 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 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 05d3de80d844..f73bff51e7ad 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(this: &HashSet, other: &HashSet) -> 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 980d9dd167d2..f483ea849b0e 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() 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 cde075501259..b3089cecfbb2 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(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 0da5651c18cb..007c488c9d95 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 fe210f697c44..50f74eeb5ed0 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 9b8c0c583a1c..f2e23b62fce8 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 1fe9f5299aa0..91a7bd3540e3 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 835c9b2aa484..c552abccee42 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) -> ::Type { todo!() }` = help: implement the missing item: `fn method5(self: &Box) -> ::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 722539fca6b8..658e2c8e85ee 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::(); | +++++ -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 e1d80f52dadd..5d8ff486e06a 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 5113dc6ec08c..2139981eac0d 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 ff7f261e03c7..5f7fb504075c 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 5f4d19439acc..4e48799318b6 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 d5f5ea870597..86193dd26e04 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 cf61e94bd86c..92d972eba42b 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::::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 af799cb6ddf3..3ac645ad3a93 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 5705e84e0d99..0d203c1aacba 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 7e8aa44ef8be..e8ded1343f78 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 9a2e01ea2645..eb02c721edd3 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 32a213c68f65..834e8ea6b03d 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 73044752b077..3426505cd110 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 f2bf22227dbe..94780a04c1f2 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(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 94bc9e6f4546..2865a4e2ba1c 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 5e427a1fcdc7..6f04105a35ed 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 c5159471fe3e..71ec5adfdeac 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 86e5f65248b9..37ddb831abe7 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 f04cb34d7c46..0b90823884a5 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 26047861f55d..6d1bd4f95531 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 6db0f0bcbffe..83779fb16edb 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 19e476c04ea0..689aecdfc8c8 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 ddebaa0129a4..706b52d3402b 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 0af083e5b523..aa0251dbd853 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 5a0357cf567d..86533714474b 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 739018663966..1e656e686fd8 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 df09ababa5a0..431ee1c0bb1b 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 34b7ea658671..5e527bf445ef 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 db4382b58fcb..ec483cb3d09b 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 225935532ead..b99b2bd9eef4 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 125e446c3325..513631b20604 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 0bcce3012630..6383e4a823da 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 cf7213637ce1..f6a5c02ad2c1 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`, 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 a184482a446d..bb179e1497b4 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 4bf207e7e98e..d3ccb0a654e3 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 065acf904a43..e0b68f249eea 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 0bb486a88937..785329565eb9 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 d56e45db13d0..4106ebdd1cb2 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 8a3076db9b23..4cfe56bfab6f 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 e6d4901aafb1..b91392f223a8 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 c53c6ea302c6..eb0c54f885ba 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 1d731be8a855..e57cce62ee43 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 9e1f4e1fe4ea..0b7783b3318b 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) {} | ^^^^ 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 365e56181001..3eb9459f6f3a 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 64d0a9077ed1..e142835a9d64 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 e166af9ed8f0..392d2f01f619 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 f63888b2f8ad..16c293071435 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 fa3db33c9606..bdeb2fb906c7 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 283aca1b084e..92fa9068cfd5 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: 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 df29fe227135..ff28480bd995 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) {} | ^^^^ 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 f7bf85815823..ee7d9070cd32 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 49f55db1e25c..aa4a2760ffdc 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); found type `!` = note: required for the cast from `Box<{closure@$DIR/fallback-closure-wrap.rs:18:40: 18:47}>` to `Box` -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 56aafbb4ce89..cbb670ea7083 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 821d141569ed..e2246eea17c6 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 67421ba8da75..8f6b5cfea68a 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 3f381b9aea9b..cd6473e0682a 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 406785bfea0e..91885380b1ff 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 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 293ec3a725d8..09379257c4cc 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; | ^^^^^^^^^^^^^^^^^^^^ 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 ce34d9483247..f59de5d2a428 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 6c71785de289..d008f88c188b 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 MyTrait for T where T: From {} | = note: permitting this impl would forbid us from adding `impl 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 6c71785de289..d008f88c188b 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 MyTrait for T where T: From {} | = note: permitting this impl would forbid us from adding `impl 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 cb3786305893..f5249814c785 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 | >::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 1cca4077d825..acefdea97d3b 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 33e3eb797969..b2ec724f3093 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 16588cbcfb28..7075965289bd 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 89781d96fab2..a17de890e3f6 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 7213ed3bafb3..aa31142b24e3 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 88a2d8fcf8cc..d93e2ffc85cd 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 4898d569235e..d76e031466d4 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 84b7ecf2f7da..81b937051c2a 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 a8f6559e4253..8debea6a0a2d 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 40f04bb6da67..b050c0566c61 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 727df1cf890c..aa73e91cc77e 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 ff638f2a1eca..949dcc78703a 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 ef2cb4067d7e..bffd365b9ccd 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 db48a4ce70cb..843d307b80b7 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 ffd526d90afa..54784df52754 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` is invariant over the parameter `T` = help: see 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 726d0dc2a4c7..53547afbfea2 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` is invariant over the parameter `T` = help: see 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 5a65c7684485..5566c76d854f 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 f7a0ee9b18d2..64deaa00fa32 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 fa9fa9e8f3c7..ee49b4dac22b 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 a20f885fe81f..28c5c43a6ace 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 2fec9bc62d1c..81b5f09b0415 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 7034492cee09..0f3e9314d933 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 d0a24a267fd4..36478e723cce 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 d0ba53925324..9a0f4bb6d9aa 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 35e4a16c8daf..a13caf8c298f 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 a44acfb5fc35..1c6844d6e332 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 0df8d8d703ec..960503e8fd5b 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 464bbc769311..8922eae31518 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 7948485bd686..82fb8cdc9157 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 862c925b468f..6c96f474aec4 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 ebaf6d1244d7..d86ede62992e 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 a1f973e0fdf5..a37639883d2b 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 dd46308d1400..5cd0982526b3 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 4a4a25790b98..e4d0cf311127 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 204eda3d2679..5e70b3017d5e 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 53845af82fb1..73599f6b71fa 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 fd6bd25b1da1..b8eb4632a024 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 7c001088097a..c8ca2bff74e5 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 7d43383e89fd..0f35fc1bf19f 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 57fd8d49c887..2dbf1c47de54 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 ca19c2501205..062e07407ce0 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 f337e2345507..69753df14f6f 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 82cd364eeffd..abf62aaa5108 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 09b9d638afb0..bd8b4c1eea00 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 0b1247d60ec6..ae30f4182845 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 0aa1eedad9fd..e15fbbdcdf21 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 f0c29b72b429..243a6011741e 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 e24606e0b53e..41dc7c8f9a46 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 38dd1b5f6fe7..a09e76705156 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 8ccb5809e397..610482f8b1a9 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 0483bda6379f..b0c3d8b878d3 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 072e96788b17..ed42899dc94f 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 84d4eb266f12..0a5e2e5a4b72 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 da31bcd54750..ed3723a7f03b 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 20f19b259671..b23ef3f33cc3 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 35d39bb6e908..62715b836f68 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 fb61b30f09db..587f30710276 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 338f64841321..fe55d8d49ad7 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 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 db53e444b9e4..f3cba9afb5c9 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 a7973829656b..8c09e542c05c 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 87ffe9b1abf4..6c82459cc86d 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 fc185d42d5f9..580f6727a882 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 d8f58b591311..b07e3669fe93 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 4787abd49d17..14ed2bb222d7 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 26c46571f9cb..269739af6026 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 4a32c777a86f..4f1139458180 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 ad0a2d1e3243..015d9e182120 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 0dfea0fd748d..2296407535b7 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 4eae9fdcde0d..b5bfdfd7f6ad 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 adc419ae5156..59130332118f 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 64ad7a21a3c5..92298c6617ff 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 59be0f983b90..7ea736336839 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 24b8c84b4a96..69df90102643 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 4f797f26a1a7..50167dd28f9f 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 ecb9ef0aef96..ac7cd54df71f 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 bb45575fa64c..d6810fe09389 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 7a2135a2ade8..81bff3ba0fbc 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 2ab49ec61cf5..eed511460cac 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 6de6b7f3abd0..8dc66cbaef80 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 ac9c59bf7f2b..eb7b57c7e998 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 851e3628748f..323ba7b84411 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 9215e850f7d8..a77ae8516218 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 4d3a90153161..472db30fbeb1 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 { 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 370cd72fd558..402c411a6380 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 03edbc3a6705..0453ef8e53ea 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 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 a3d87d74a8e9..b5e281538f9c 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() { | +++++++++ -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 58e378ab0211..5f8e9d5c6ac1 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 36f2cd0b85d1..639cba1406ae 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 55646b9dca98..56c1fce0650a 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 c89f94a7894f..e6f275a241b4 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 90db13bc5784..610a0d6e9cc1 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 15a53a09af8c..7f231c48822a 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 72d99aad99ee..fcb191891413 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 9be2670fec76..9500e474bc68 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 321d17ba6b10..94483e94a85f 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 1cd2579e4c43..84958eae5b46 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 ae9287f92266..7a7c7801643d 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`, 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 0fc3670d6c52..c6f3f2fd018f 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 6df5563eabbc..9deca6449a8f 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 d111256b8454..73fda380522f 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 000bdf85804d..ee00b7ba51f0 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 5672b9cd7e9c..b26f73fc70ab 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 c03e38579061..b7c37caa20f8 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 21073647ea77..0e3ab41da871 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 d75ec2b57d4a..d48745d2d281 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 aa1927711b36..7f7b94c0b301 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 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 fe801b42c0a4..b585eee0769d 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 ff6ea598ff46..3f9a6cec0d2e 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 720440a0ae5f..358830fd5161 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 efd56ea2dd54..9fe681680c6c 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 0868984734d7..135b69515373 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 cf1c52ba7cc4..f6277508eebf 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 320f529624f0..693c5b8b0a3b 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 6de023ffdd41..2aab03ee7b76 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(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 1fa74f67ccd7..f8ecc0c68267 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::() | = help: consider adding an explicit lifetime bound `>::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 c8dbe4ebc6d9..13ad665e2615 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::<>::Output>() | = help: consider adding an explicit lifetime bound `>::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 f78708dc48d9..b4136be36d31 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 0048eef6779e..acbcb9f0b70a 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 73f01ff1519a..c884909c942e 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 cb02d76205c7..582ca17cccc5 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 91e7c6b8ecf1..2bd00a51fe23 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 3b9363c41f20..35eec233ed5c 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 c39301588acf..cf699a3e476c 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 | >::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 541a2cfaf299..ee06ac7407af 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 ea0fcb6d634c..02b17a3856a7 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 ff549f1d88bd..06e4848e71ce 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 | >::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 7f160d8e398b..754e09fe326a 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 7809b2470fed..0cabc02c6b5d 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 ffbfc40f5372..c1030152814c 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 fb26b8d09e17..2d2397456c94 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 69dd1d1aaae2..99d57902d6a8 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 132a00ba4158..ca99e5318709 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 766877f8835c..3e2706309b34 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 1d3ae7cfbd74..dfc5410b7446 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 afb25e3bc69a..41d7e6237b4c 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 c46cfcb41341..4cc7e5ab1b4c 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` is invariant over the parameter `T` = help: see 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 296e1fb3f26f..38432c851c52 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` -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 068c7139ed9e..edc248db09ea 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 bcd481c33f36..cdeb6eadc174 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` -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 33446e9d1624..9c30261e5cb7 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 93da7c3e0ddd..85d8f87afa67 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 b5a14b551dc2..3b66c7db545e 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) {} | ^^^^ 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 ce25da559da3..3534167870ba 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) {} | ^^^^ 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 5b453e0da3bb..89939216d5b1 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) {} | ^^^^ 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 9ce3a318f1d3..9c7a921b8d8b 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) {} | ^^^^ 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 bf88ceaa5d2a..59759b696c7a 100644 --- a/tests/ui/noexporttypeexe.stderr +++ b/tests/ui/noexporttypeexe.stderr @@ -13,6 +13,6 @@ help: consider using `Option::expect` to unwrap the `Option` 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 d684b8eaabdf..c9f977fbaa40 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 99af04e7cd97..bef1e1077ebb 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 0c696163a26c..b8f7276c898f 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 2a7037121876..01b4a9a7ce02 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 17cf938d170b..783c165eeb21 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 93e011ccec4f..50e25a24d811 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 cb78370b48a6..fbbd81d6d4c5 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() {} | ^^^^^^^^^^ 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 37a6aee39066..cd792eff9266 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 434c9d5b43da..5d2c4a6c8e27 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 c3b44e5a0437..8ac72aefe0dc 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 9d6479bd7c7c..43d541b03043 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 2bb5b6a6d6e0..00a3581069f5 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 b2b3114d1b4c..62763e9e1df8 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 ad18c3bb7f45..519e62fef7d8 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 37d02e09dec3..de24ea1fcde9 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 692602c07198..47588012fb69 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 e3b5859df90f..e9a1572d3cc9 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 a3475c04c28c..005f7378226c 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 55a61b5e4437..7b20d35c876d 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 f06a9da1deea..8d44b4de55a4 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 51d8450af768..0846dd60723a 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 f721bf39419b..688f8af0822b 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 { &() } | ^^^^^^^ -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 61e96f59fed9..b59956879275 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 7d6f9f39d13e..b49e506a14d1 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, 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 2bc8e097859d..9e2422fdc77c 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, 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 110e71507337..cd2aa9fdbe3e 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 5041ebe77605..2215ec677c57 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) -> Pin> + '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 5f94c9284ea6..462d3d95f13e 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 db3e0885a85a..d0c78f9cd699 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 29ffb5448427..bf3c055f4e3f 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; | ^^^^^^^^^^^^^^^ ...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 17f4cb4d4a88..1701f6059a8e 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 2e59d88bdaf9..c9c1437a2619 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 b40470b457b3..c9e076c65779 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 1eae9a9b9daf..e155a350f894 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 b019264128e7..7b91c4d665cf 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 90e5c59dd027..69af9bfe92b9 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 97481312142f..66b5239745b6 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 a6c22b8747e5..1d0ffcffd045 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 a106ab995b0a..08df069275a6 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 { | | | 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 b68c3fa5bcc9..7b6fb9fafa20 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 04c404d543a9..675133b6d50b 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::(_) => { } } } | ^^^^^^^^^^ 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 fdbbdc3abb37..1cb6b32cb233 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 2a520f6f9069..1845822f11db 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 048b72ee3bcd..7c0874e36a6a 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 a4b33963fb0b..45ef22f4421f 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 36d80f3e681b..e2ba2474d6c6 100644 --- a/tests/ui/on-unimplemented/impl-substs.stderr +++ b/tests/ui/on-unimplemented/impl-substs.stderr @@ -10,6 +10,6 @@ LL | Foo::::foo((1i32, 1i32, 1i32)); = help: the trait `Foo` 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 ddb1f50f0bb4..4ba5475d9eca 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 335ac6338226..33dd840dbc2b 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(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 80c921535bd0..21b2e77db9aa 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 ed6bd74c9b92..46a81db62b42 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 73270284131f..1b9614a13782 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 2236a38c37b2..10ec7c202e4d 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 058873ff5ff9..97800161d82f 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 7ad62ff99ee7..1f3d2d5d6d59 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 9f4ac0fea36e..ab33b703a05f 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 7a7cea56307d..b9fa7baf4c27 100644 --- a/tests/ui/orphan-check-diagnostics.stderr +++ b/tests/ui/orphan-check-diagnostics.stderr @@ -7,6 +7,6 @@ LL | impl 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 e4a5c98dc5cd..8582b8123bfe 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 744c832dbb40..e91f49884298 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 80a8919f77b3..4d75820e9449 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 cf5f4e530dc4..7ee732217e3f 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, | ++++ + -error: aborting due to 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 57630a4b4701..a464b1893878 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 85555c43906e..812f7a0692f4 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 84eba2a5a63c..736a4c7094c5 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 cdf55ab6534e..6cd072c63962 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 5e46da12142f..41a12e8dddf6 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(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 20c17587590c..3dcd253d3086 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 8cdc4888d022..5c50b7016b20 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 2bae12efbde3..06ff8e3098aa 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 7c7feffe76a1..ad9addec8eb4 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 4210a4200aee..c38feab49c3b 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 704b81ae1ce0..bea1172f0e31 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 d29c7875fd0f..2a13f45c1e2e 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 4c71df3ebc14..2a0647fe700c 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 d306ce6c5ea2..ced0a7610e2f 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 fc313715765c..da2f57033a44 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 acf71b4893ab..0d49d542f732 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 d3b90c34c29a..5ba8eb51bbca 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 b637702f21e9..259a836d0979 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, ::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 6fc6fb665a80..98321827dfa7 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 4fa420c79fcc..13eed2e1dc8c 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 8d65c423c8da..4ca7d6d9fe6e 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 a2acb94372b8..18a9d77bf719 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 b1bb3ab3b17b..c7b948ea8f76 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 1c892eac08f3..882400c1d6fb 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 0de3490b8ea9..b77f30fdb593 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 7cd0ac2244af..2e0b16efb6ce 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 4c5964715db7..3279e4e59434 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 135d98457e19..f2bafa54f8df 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 45d24bc0fb36..6dd4ad512a8e 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 57def42b1ee3..8568036d0562 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 13784c409cd2..8e7878c2b6c0 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 a36b67794fa8..e133d4e4839c 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::.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 e843c49886bc..f409d4d9901a 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 bb79776dc845..f27efc95f913 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 30c05ecf30a9..971219496745 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 74137fa7001a..b7b73e5f814a 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 21bf8d19a721..6cb9a49605ff 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 b35762a887c7..6b366a99569c 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 82937a517b5e..f339c2022751 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() {} | ^ 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 000e84f635b7..101704f6442c 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 dd3e69c11396..f39cc604eec4 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 b6bd866938be..f79b4fa03383 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 785a1fb67932..9dd963afc796 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 e47a21d892b2..26a3e78633a9 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 5636ee75c97a..709d31430984 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 9569ababad8d..247009be0cbd 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 d73de41a8099..3bd048f8f622 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 3a4dea95d5dd..5290e3594d55 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 3d16a2067cca..eb8428854afb 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 766d72a0a5a9..d837466d9af1 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 `` 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 1f2850374828..7c9033f2f322 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 | >(); | + -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 eb5073e14cfd..78f5d7b63b95 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 63da5c2a6e1f..20e551c2f959 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 -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 abbf3fb41e79..be94331dce52 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 -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 933a206410e1..aabcb826c128 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 -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 850e2368e55d..eefb2792e90b 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 -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 9ab3631a60e8..a3092ebfcfd3 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 -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 7ca2495b829e..c6c6cae87659 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 -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 d70476a98331..bdea8c841c63 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 -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 cc0b3da664e7..749941290cb8 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 -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 cdc19f8e0765..f01bbe8ba034 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 -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 d673db89837e..8dae123c96dc 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 -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 e0b6f1b5eb80..6995b8e6f237 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 -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 67199179b392..d4636150e66b 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 -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 12e6f57dd501..6d376166a7f7 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 -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 7b43c77005ed..0227439ce066 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 2fe6a28eeb41..2796312f4ad1 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 14fd01af2f98..0298b9b60d2f 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 82756626765b..e41d02f0ea4d 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 8fa12ec261e0..4d952e294262 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 6ea68e42b4cd..bbe6b7144170 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 940d293b6786..501b05c5a948 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 d5749c66cd29..00aa40b62113 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 4d4741dfe59c..3c4ea5375b53 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 a879e13ffbd6..f3454d30d197 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 94934f734b39..62a27740f56f 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 6b5c8c1f8b53..66c6ce8940ad 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 900124adcc3b..df1ebc1106fd 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 e7203f24d3f8..208c04bd3df5 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 10aedbb92a1f..25403c5b027d 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 8ecebf01f17a..b578b1fe26e8 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 6ed309eba939..cb15c36e6491 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 e9d287ac0e92..f83bb3e3e35a 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 258a2c2680aa..c2200e037634 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 eb75c0fc9c6a..10c58aeb571d 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 d9183d564636..2e434afb218c 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 1de918782056..b61a62a17f7e 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 f34329012a02..972c861c7502 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 2f6cfff350c9..3c8e586c0e8c 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 355741e8949a..9dd90798d926 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 43c33a2cdd7e..504ab1bb93d7 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 c757232b061c..eb2e273602ec 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: 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 0e69bc4b2ce5..6117370c0ce6 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 ec3bee0ce682..579f4c29c526 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: `= ;` -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 1acb727368bc..1704d99cf29f 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: `{ }` -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 23dcc1efd68b..62e0d085e275 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 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 93bdf82d0f57..b63e48d6679a 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 d78f6de9222c..2f267a8d0269 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 a93ef255c94b..3bde32d1ea4d 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 e1a026b639e7..24e6c3f00063 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 3ec3ad8e977a..6dbc0fd93fd4 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 331c254a52b4..57ca164fc15a 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 49d6aa5eff8c..d65a3052ba93 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 b2c661296560..27f0baec80c3 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 f7e78814ca57..df34e2a42a9a 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 86658e4f39f1..07d136881408 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 1b30d4b17861..56348357397f 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 8af887050023..40f1d339a45c 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 52b6ae5df359..cf05337f26c0 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() {} LL + fn foo() {} | -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 6aacd5012c14..7ad816e451ea 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 4154ecfeb71c..3e5d5062bee3 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 438ea67d33cd..85090d054e8e 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 d06a6b2554bb..fa20b5f8b162 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 0a7408e2c173..18c04dfaf208 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 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 1e6294ebe169..a7402e0717b7 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 4cd4be1803e1..2dc615246a79 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 d2d613461186..2d0c3e0e675c 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 7cda667570de..78017babbf60 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() 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 f68d6d5010d6..e12283b25ad3 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 e6595a5cbcc4..bcfca981d256 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<# | ^ 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 ddacf4d6dfc3..36f6c5b018fe 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 0789c4548a08..a47dd4103699 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 -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 97304a89c9e4..5db628d59776 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 a0c5e665ff8f..6d9f22f6a7ce 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 90dcdc427757..02323cb99cbf 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 0c152516abcf..1986f70bf672 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::>>(); | ^ -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 57181577600b..2de59b8c746c 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::>>(); | ^ -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 ea26453f8089..c88fd4e55e26 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 cf8d01147876..c3c56c46a6d5 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 0c390a0ec563..536b583aaa32 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 8251ce9993fa..a27f517086ef 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 7185a5e5752c..211ffcedd582 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 { x: T } where T: Copy | = note: for a full list of items that can appear in modules, see -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 aa343975dcac..81c6e3bed1cb 100644 --- a/tests/ui/parser/issues/issue-17904.stderr +++ b/tests/ui/parser/issues/issue-17904.stderr @@ -13,5 +13,5 @@ LL - struct Foo where T: Copy, (T); LL + struct Foo(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 954cc0beeef3..5ddc5ae58d9d 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 49043d07b35e..7c802e4bdf7b 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 1da00960adfe..236fac673b6b 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 816046237854..b7a8d22d8ff0 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 42059685c5cc..038b2ffc72b3 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 dbff116e505f..10e5befe2a74 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 = Box,,>; | + -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 48a06e00b24d..df619b4c79b0 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 = 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 84bee2ad1842..709a5467deff 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 67de41b9747c..7fe1f1c456f4 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 3b8e07fa0d05..d9e97301f5d7 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 e9f37e50fffe..f8d7dc63c94d 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 dc309d1bce15..5dccacdb6103 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 = Box; | ^ 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 12b18bbc5941..9fb7298955b3 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 4af4b22bee29..256fb0ade721 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 c71fda3d63fe..e83c62afe799 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 `` 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 cbfa9ded3c39..8839eed8485f 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 585e70266619..bdf74af6393e 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| | ++ -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 7f9d99d8edfa..aeca95ed68ee 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::> | ++ -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 7ea0f2a98285..edd64ecf31e0 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 b89ed3958357..fd649a575c6c 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 fd7015ccd390..3ef707f3953c 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 7aed88768a07..bb1e19e9e6d8 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 d9470191b25a..43e200102259 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> { | ^ 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 e02223931c11..3dd89b7e828d 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 76e68b0b3524..d3d2c2a0f9e9 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 d0a9b529983b..2ef4305dfd0e 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 >() {} | ~~~~~~~~~~~~~~ -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 7515369aaa0b..7319e839b934 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 df12f7768d42..c0513a64039e 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 2aff32839353..ec4934eb7221 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 c535ef23b229..573614a5e995 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 b451484ba224..b2a6ae93a45d 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 0e2b0d62ef6d..1e72f040b036 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 393d1f2e2ce6..da85bcb446cc 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 baf998035178..1ce3aa671359 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 b888cd989a67..8a9326f90c68 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 69ff64c2772d..d005f116e124 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 081a72054e8d..1d2281df108d 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 0766c8a33df1..c67c271e19ae 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 6177870d1cee..488a046a5490 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 4a5653fdb513..7b50e0ad0fae 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 6e68c75850af..aeb13460092b 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 5d0e76d5d944..65e6f196b091 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 2fa05dd2dfbb..8031bf82fd1a 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 dd70b40224ce..dca0d3ea4863 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 bdb5c91ff91e..4b025bd19a04 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 a596a9f2de3a..a2ea8ad368ba 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 c79e8b4fb708..14f5469f6af9 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 77ad8acbd43b..2c3334391978 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 5fcf5bcc17e8..d3255fca0210 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 cd8f1231fad0..b40412aba558 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 03f51c6e3a8f..6bdfec9384ec 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 fa7c626f5cc1..dd86fc9a7f85 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 0cbaacd4c64b..d83a49aedd6e 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 80c1c71689d1..6889cb3b8e9d 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 4637c795ae5e..37314dd39c7f 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 14c0bdcb111b..310b433f2dfc 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) {} | + -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 e57cbd1810a4..2165a81a0482 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 700479076dfe..870633fc96f8 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 d61197dc566a..2e1ac080bc5f 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 ff9d99c28fe7..9204f561e965 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 4a3bc752553b..83fc029967c5 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 079fff37ea4f..a265cbf70a65 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 6674b924e9c4..2423a7526be1 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 0b9c364f1f1f..43047ff88020 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 2d873b46193c..5b5d45a7e872 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 cabd133242f6..782b85f09404 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 604b7de33194..a8487b5f4bec 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 f03c92e1b1f1..14cf52ce672a 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 46cbb056d1d8..c4621b2b84ad 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 c590e04bb3de..a21cd4875f6a 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 477fa09f495e..c4fc662f5d9e 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 0bb99a01e55a..c596c6abda55 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 2c9c2a8cfba9..7f2df5c87364 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 2e91beda1165..a703fc4e8a45 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 21b96c14d7de..a9acccdce182 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 cf80d9a9037c..4c36d773d60e 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 fa8f13721c89..4ea76179be3f 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 c63292ef8539..69f7927750bf 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 50b23329f0ce..25858981cff0 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 a62226a8a4de..b23b09e752ce 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 40873388dfb8..f1287b82fa57 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 4c10df1917c9..87218a4487b9 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 7ad59f8450ef..e866d3922675 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 20761180e77c..d9b6b336a2ce 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 523cc9dc588f..0d636bd28a50 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 575d857c0ed4..dcde7242d398 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 e9eb14bf00e7..74989502e7f5 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 0d2bc3472965..5958f0c7d2dd 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 4224713ccb53..0e9f7c51e1a4 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 8d242bc9de58..a210238652ab 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 94c6a29efcb3..6f686a7e5043 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 d045f4821ff3..fbe26ea39595 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 d61ee23a50b5..35dc66a528a9 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 836f44953d4a..60ef025fa8bf 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 6e624c5a284e..10e0161066d5 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 366d05c2d948..d4987234a49e 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 fb1312c782aa..5f8f6f939693 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: `: ` -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 a5ee24445200..51df17c7cc67 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 2d9652051dd5..99339a285ede 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 ee0cb4efd74c..c653c8dd4a42 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 d568a4c583af..7dd059c6e3b0 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 81dd39bb7695..5e4b4dd3001a 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 edc640bf5ec2..c503bc3ccfcb 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 b7d1ce7cd7c2..156e098dab93 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 3c5ad950db87..bc654cbc7c3a 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 a4535eb40a15..63a9cbae5193 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 31922f150e53..61e454174dd7 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 81285633faa1..2519000d28e7 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 2125fe84aedd..e3eafa8fbbba 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 92d092ccb65b..280f8a2e1a11 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 f1f9f2e2c90e..74866c9e7f93 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 645efbcae713..32fff1a6189f 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 26407cc4d3ad..813bb3f3bd30 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 26f9a15a7d00..245ff8977b31 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 73a50bc38bcf..fe840ba3d22d 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 98332b723f27..12fc0479f706 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 86faaed382f0..69f570aa8385 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 304ad61ccafc..ff14af0c7d74 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 25ac397fb7e2..3811ef058b98 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 d5688e871b2d..c60d6f1295b2 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 75653cffc13e..91cded8e9fbd 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 040960835d81..335b31a20e11 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 cdb5736866d3..108a621a24e7 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 8d513507c810..ec62fd4cfdef 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 618043d89ffa..54c258d7ad97 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 eeb8e468ba62..9e41d0ccbf69 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 a3213e2f2974..76fb3afd681a 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 b73361a5585d..89eb644e106f 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 56ef5f60690d..3f19f6f3c81c 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 94a106d47d71..ded65230262d 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 624c1006b12f..5e6c6d9e1d51 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 4c5324505e96..c671ba94c4e1 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 b552c9cd3865..25a8001c6816 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 630798659a8a..26bf2b4f64b7 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 9e72f7940428..5243f04888fa 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 2bb62105d170..ea396c61384e 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 ee7d72b3996b..54539519ec15 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 ee486c2366c9..4f8e2835e085 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 a61fb5c85d49..12e6d5190603 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 f2365fed273b..06f72cdecf2a 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 d794671f8ab2..bfe89e320e01 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 077d31800489..f9a3072229f6 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 3cd8accb6629..ba6499d712e5 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 da9e743a0b44..1f2fe23106ae 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 = `, `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 d7919620449f..cd91ea441226 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 eaeb62d2cfd9..9d2d1bc00725 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 1dcd95f6fad4..22efd995b463 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 1a5f4696858c..1b34d2d12b20 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 cb361a3db538..7ef5228a8edf 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 851bef8f2c7e..72dfcd7dd7da 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 d2af94683eff..d45a2e3ab529 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 dedbad909459..f7822ba11246 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 d91a7f0542d3..97aac661d465 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 d01d9ed60e41..f70dac443e55 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 { 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 7418dd64c9e9..a565ad49b221 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 165eb8ae9328..180798788df2 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 6d8b0c3fccde..29a5dbb737af 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>, | + -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 74a7c4224fae..74acfc829a43 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 e0d5e84ec317..4108cced366a 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 e240f8c6739e..cc6d30c9cac1 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 994ce4d8541c..4815f04fbce0 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 56df71238192..fc718d8556df 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 cd1add73d584..9ccb775daab1 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 cac0c801a599..450a91207b72 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 5a8bb2f7a457..6100f64e3ecd 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 d82fa80e594a..a23c23c41df2 100644 --- a/tests/ui/parser/nested-bad-turbofish.stderr +++ b/tests/ui/parser/nested-bad-turbofish.stderr @@ -7,5 +7,5 @@ LL | foo<::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 b85bc02568c7..8d69125f8e95 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![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 d133e46b4b0d..491915c89cc4 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 2f3f8c0f9dae..e0bdf533d3e0 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 514591af17e6..d62afee7f009 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 b7108ced0d76..d5f404bed310 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 ce2eab051add..6f2a9f64c94b 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 6ceba07f4691..7d40cd63ffb7 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 7045b6f5b786..8162db3d8e5d 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 f396e5fde5ba..d3d6c9b08102 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 e8ccbad668a2..14e679bbee07 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 c78f96e1addc..5fe97b2ef4c7 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 afdf1e9a5576..cdb1b3177353 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::(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 b71a5ad939e5..92d16564ab4f 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::::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 e23674bcec58..e556e6c0206f 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 b64a3ce5c083..e4d4e145c065 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 1a9e33bebe91..c27436a81c5d 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 c9787b789a88..611b35a65028 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 69084b5a4147..c30160291d60 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 a3bce3372646..ecda487d0c55 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 391f2c428bf2..579365730c34 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 9ac0611c5c93..7ce00462be22 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 7c7a909267a1..35cbf4230791 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 795a5bcf5dfa..3fbe8d0b164e 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 efe225656fd7..09d564d7a39b 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 72efae08dda8..b9b924e670a4 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 af875491e85c..c98f8a9914e6 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 8857d2ef30cf..6e5af8cc1f0c 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::<: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 340167f1804e..c8f26a3ba1b0 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 720d489389bf..a797fa319c47 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 d37b6be4fa11..83df719dd3cc 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 8a91782639f4..0fd7f28db317 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 3a7e2a4b14af..796b1324a5f9 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 a76668e8051b..88fd53904c43 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 2a40dfe200cd..f42c3e8e70c0 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 d7a364d8579e..2edba430d1d6 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 8a04f99a126d..5edd18cb4a99 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 077f763f154c..9d15a28173a8 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 8bbac9d7bd0b..90dd9775e62e 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 b2b853a89e75..6654ef7a75a4 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 29ec17842aac..1c46b5385cd9 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 152f7f2fb062..cf50c026665b 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::(); LL + bar::(); | -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 79437533d7c0..39a6682fcaee 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::(); | = 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 17237c930979..2b56498c50d3 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 318e55f6e99a..628626926a78 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>, | ^ 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 9f6fb06caa34..51a9e707756d 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 93a6a66a6308..e181f07201e5 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 78c67866fb0f..f0050394ba0e 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 bbc657ffd614..5d8f6af166bd 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 e107c6b78b31..4c991d67ea75 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/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 8f7ca356798e..5b917e93853d 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 9bc18dabd6ea..339d056e6360 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 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 532d4fb2b61f..522912a9e1c6 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 a2b97544f9e5..5bc9c2ccf00a 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 d0393b379f06..fd964c4b7f04 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 313420fb9a4f..a1aa1ae49e36 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 02b518e25167..beaae7cddaa9 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 914de43e62d6..5c74efffabff 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 0a1655840b55..dbf09f1c75b0 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 63d2fdb8cd4a..7aaedad19d86 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 39db0be9fbbd..5ae1f4f587e6 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; | ^^^ 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 c3f747b61b99..78042678a87b 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 47d8381b0b1d..9ceec8d46d38 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 896a9dc83d8b..41cd4fb93faa 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 a36b2a2f72b4..92fefded55a5 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 -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 50543e8bdb81..56991c96b7a0 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 90acfc052ddd..7070232c1423 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 c2cd7e82ead4..d850ed620de4 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 692b4d73503a..5177f5f126e0 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 2ddfa07c5be4..7ba1dbdff7e5 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 94e44ec7f6ce..235e621d8827 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 396e0c130f11..c716d5908ea1 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 d7cd6efae41d..25b0679957ea 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 8a33321fbd56..f5573f5e4e34 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 5f5947627ee5..7bef9d709880 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 Foo { Variant(T) } LL + enum Foo { 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 89716e6f1ed0..e887c0881511 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> f(_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 061d0910a742..18e173a9db01 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> f(_x: B) { } LL + fn f<'a, B: 'a + std::ops::Add>(_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 47e12016938d..cde69083593b 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 e749f1a0d00d..e77df69eeb1d 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 id(x: T) -> T { x } LL + fn id(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 2b650907092d..09e176adb4d8 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 Foo { x: T } LL + struct Foo { 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 ac86cfa46970..0d0b780d41f7 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 Foo { LL + trait Foo { | -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 22744f6cf37f..3034535d5562 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 Foo = T; LL + type Foo = 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 8a44e02707ce..fa2677921b32 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 c096ae04fbbb..e3d33bf251d6 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 8d2d5e3d7ddd..7f51bd97e5d9 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 a6add6079cec..23ec1e9cf3d4 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 c14a2f2eea52..436f6a3909c3 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 7f6e7350ca7a..279e3a95354b 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 2bf1d468a853..ee8b6f7cb62e 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 94b300a7bd76..d40b982da7c3 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 cbc5f8de4c3a..acd92ac79259 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 a46d020b9672..1231decd9ddf 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 a46d020b9672..1231decd9ddf 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 430a13e6e071..c6960892b2bc 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 773bb33d8d3f..9881c6ba51ba 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::(); | ^ 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 4acf72c5dae8..77f6e93be10b 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 3d4ed526b6ac..1bb4aa97d8b1 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 17e39b292005..10f4c8332a36 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(); | ^^^^ 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 bd0d881a06c3..2f8e09c07e18 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 ad5bb2de1b25..6e624cb91316 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 268fc1057963..7b45e77ba9c9 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 -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 b80b0a409065..4bd0cc885c99 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 2dac45c115d1..0bd68b7b9aec 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 a481ca468338..4a6d36a4e0c1 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 { | = note: partial move occurs because value has type `Box`, 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 c440f4619f52..815a4ade9956 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 e0e623fa544f..d0ffb59a6ec1 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 ffeb7bc13650..285c9109e1b8 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 e6cb6c1ddac7..c1e85d0bb48a 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 69b663b17d34..dcf3da45e535 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 f40642f300cd..087ff513bb32 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 0519720694d7..b503a17fe849 100644 --- a/tests/ui/pattern/issue-72565.stderr +++ b/tests/ui/pattern/issue-72565.stderr @@ -4,5 +4,5 @@ error: `dyn PartialEq` 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 75b6c163b2cc..167016397d21 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 dee4b3f557c7..8edb95f76f07 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 e0eea06e0a3c..e938c67f3087 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 d3ab533e35e4..85379d6605bc 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 65030b622500..494e5e2b2e85 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 0c5824be95df..ad175710b096 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 029075293106..80bedfe7859a 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 4f482c52a98f..c100aa6070f7 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 62283dfe9b64..942a42650751 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:: => {} = note: expected enum `Option<&str>` 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/pattern/pattern-tyvar-2.stderr b/tests/ui/pattern/pattern-tyvar-2.stderr index 121817e70569..c6540e795589 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 -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 4eb00254861d..492b34cd2920 100644 --- a/tests/ui/pattern/pattern-tyvar.stderr +++ b/tests/ui/pattern/pattern-tyvar.stderr @@ -9,6 +9,6 @@ LL | Bar::T1(_, Some::(x)) => { = note: expected enum `Option>` 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/pattern/slice-patterns-irrefutable.stderr b/tests/ui/pattern/slice-patterns-irrefutable.stderr index e98ee28d6868..9b46f8a88546 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 5f2c89246e39..77d552b0cf65 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 dbd46da44131..2352ecd0a470 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 fc6748958de5..ad9046fe2482 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 7f26c93aa28a..9e35960bcda1 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 771fc320a13f..96500ddb9cca 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 7f15c4703a31..199bdc6ac978 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 aab2be78c9a4..2b6e2e14b7ca 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 07ca56a566ff..ab80c56ea88a 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 ee8410b76508..cd6c30511969 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 7f7c5a0f19de..18ce7cc58c56 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 59d64bc256b5..74d39eba98c9 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 d8884394f8e9..8a81116f0dda 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 2df8911badcd..3eff2ee9bb1c 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 5367de5e513c..cc7205658284 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 b8c987431012..ce18b736c108 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 8dc534916061..9cce87a1c65c 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 40b42af26b34..894cb95c7bb8 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 293273174101..a38f360c88ab 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 7880c8925671..90df1fb76448 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 50e13bdfdfed..ea21ee4e504b 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 123dd051d249..1eaee1bd3521 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 bf05d616d6ed..2acde8496506 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 2c8c85bb1e00..ba7573839ed2 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 45352f09417f..d760790dff6f 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 fad0940baa44..0dbfa776f695 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 63d1f38e9db4..30828ab6c90b 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 9fbd871db7c9..a966444159bb 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 01f077909e8f..bd6c5002e63e 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 3d2b540a9f57..17d937bd528e 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 fbee33de6f30..cc29c42e4d68 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 ef707ed4aa40..0b21bd3f5f06 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 4a4945156f73..5f3e5a7398d9 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 d43027657f04..9af1cd2a16c9 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 a8d0d6236040..34aaea5b70bb 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 9d0922ac7ca0..a3033d1dcab6 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() { | ^^^^^^ -------------- 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 fcbb86949232..8ab0320aafea 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() { | ^^^^ - 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 547569df7dce..a5d3bee11d94 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() { | ^^^^ - 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 5bc6f07fffac..1ca75ec36ca4 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 e8906985e059..778ded2df991 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 231a4da8b5f7..eda42c24c1e2 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 14a12003e2de..b00e566f8f9c 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 600dc7c876ff..c5bbef97c344 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 c8057d85ed1d..78c79fc951e0 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 f45f3d8ec372..5c986895d64f 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 7552fa71a3a3..4aa3ae964c0c 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 98ba7856e57e..17d50f24a945 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 18e4531d1125..c53232e4c8c0 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 7cc8bf0de2b9..d3da2326abc9 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 63512f462f51..73f2249bc6c0 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 e3d90150e2e3..330d892e939d 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 e644440c827a..9c524e2bd377 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 0104a1b27e48..dd36afe8b36d 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 42fec7622658..076a149e1a1a 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 40cf3448d6f4..ed4c83f159b5 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 9dc9db0eaca4..2a35537237a3 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 630553036832..de24d1e09622 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 facf4e82fd62..cc5a966bc9b3 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 eee964f022ac..dcdadf1da4bf 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 294999798667..e6b76322f964 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 c7ec72ff1662..e8d88906f1f5 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 b630565d0237..9f2291e6825a 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 bf6a2b625d5b..7b6b84bfd4c8 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 650766458465..126330b14a63 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 316eb636ba82..346cebf639d1 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 df8b6d5f382a..945ad46bf33c 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 bf1bd8427c83..a39ce366f75e 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 186f38a00f91..f5cd455435d4 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 99289fdfe7fd..25777f72b8d1 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 a0dcc84eef8f..5123b823fb87 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 b27dcd7e6cdb..dda590ee8c7e 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 36a6a9bb3e72..410770eca08a 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 9441cdcc8cf2..1c12a2804c6d 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 = 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 aae621193ab9..c5d1648abfe1 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 78aa84401a50..0013bfd16a81 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 66979e756aec..3de2139d5d7c 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 c096bc8c0439..158ba0d4fb74 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 4122253d22fc..b541051147d5 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 0a116d6f80d3..9ce783073fdc 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 ddd0a0874dd3..004915564507 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 23e103dbfcbd..1cd3583135bf 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 f7516c7d377d..08e679a7c559 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 fe2464b3b811..fc4c2062fd7b 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 { | ~ ~ -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 ee0a9bd7783e..3b5f9e3b5b07 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 d69de23a4c0a..7bf85104db3e 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 a3b2de01ddfb..8adc4c6e0dbe 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 ca524176035b..50f9c71eb284 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 ec0e3c4c7546..02fcaf542970 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 a92f07522e5f..aeb824303e71 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 b544be6e96a2..71d0ee10aa2a 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 0c99809ed5c1..315b4c591724 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 4dd8be7d9b6e..244d218608be 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 c1a642713d29..18f513586726 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 f0d62f690fd3..bb429ad631db 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 d3516375291b..f14b5fed6b9e 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 517cbabd5c65..e7cd4474618f 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 efd9ff22506c..c7d2881ad213 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 a9e5256a0a95..3dda3cc7d5a5 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 90f94b677e90..ecc0202c106a 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 905a5f9463af..a72067021cb3 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 e7d95cc83581..6f50d89f500f 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 ba5c8c1571e5..2a53145a6436 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 5d12e149c3c4..3cab0ae67900 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 deaba1cf272f..a7524fd3b0af 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 deaba1cf272f..a7524fd3b0af 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 b5b667b41b67..e724278b2339 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 c4a196eb2c26..a8fa4bd3bd3b 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 6a9aeaf4a56a..b0d5ce9de5c9 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 c1ca0136b18f..63fcf6bf5d59 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 cb94c48add4b..06dac616443b 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 6969a376a5e7..5e0f328d9861 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 d94198a6b6de..d08e5120570c 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 90c7138e5cee..470874e06378 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 562b68e35424..0e08a5ff4492 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 d3a378786e4d..2d5d61d93810 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 0e0b127054d1..750e2d17e0ad 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 b47328f34e6e..4db848783179 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 e0ea50621f75..1402ec231cd2 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 b6cf19b8286c..56644bdd46a8 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 = <::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 67e0c2545515..fa1d033754e8 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 35e608b6b232..e86e38225a36 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 43a18b4e0745..d455e0e4ff8f 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>` -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 f6788d034e6f..2e2d7983c03a 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 bb4e3a13a5cf..84294604c80f 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 0829fc2ce9b8..04778eecf569 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); | = 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 db19d1baec99..094cc146b6c1 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); | = 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 dfc74f87ca71..7c66d1c749c2 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); | = 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 692bd20f5094..f4a56fcbcb2c 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 a3c54e135604..5dec512ba5de 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 defa87046102..1949af2a9a0c 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 3791559f4400..c9766f14d2cf 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 3c562a7ee6f0..68ba6529a1dd 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 3cb4a32e02fa..70536326fd84 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 1cbea8288d46..60db8217640f 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 263a1b5a960f..824515a2271f 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 cb1b760c282b..52be0277c00c 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 80ffa5d73f03..1dea9d813f9b 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 ca1d2be65ce5..81faa59a07bb 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 514bed607003..e77fb025bcf1 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` = note: cycle used when computing layout of `core::option::Option<::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 002dfe115b03..a5bbc5499a88 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) {} | = note: overflowed on S -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 5df8af484a9d..783f9cf76325 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, = 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, {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 cf08095372b0..7a9f04d4bd6d 100644 --- a/tests/ui/recursion/recursion.stderr +++ b/tests/ui/recursion/recursion.stderr @@ -11,5 +11,5 @@ LL | fn test (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 d662d1022038..b584cb466968 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 { Cons(T, Box>), 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 f39d0a0d5e6f..71653d26a18d 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 b112228d4039..570d203d07f7 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 1b4d80d90571..5abec88eeff0 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 6d1409bb3906..94442b5747fc 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 0189e99da371..aa4894ec4d8e 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 9b1114e9ce62..fd53d248c4e0 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 35ac2c4cd17b..b2e8c46c372a 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 9007ec0d7844..fc03cc5b604b 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 b43565909a3f..f97eff19338c 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 d76a83b02580..509863eaf886 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 3d059ccec729..5ee7cc7866c9 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::(); | ^^^^^^^^^^^^^^^ -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 320d008aeff2..70953808b816 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 a4230cf8b5a2..e07dca0c7ee2 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 56f4c0c5db4b..fb3373091c22 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 c97e59195ed0..e6e629321e52 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 a29dac4c9c87..0582295832f7 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 7f232e4a7b25..113c84c65628 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 7f232e4a7b25..113c84c65628 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 e204c918724f..0e3aaaf5fdbd 100644 --- a/tests/ui/regions/outlives-with-missing.stderr +++ b/tests/ui/regions/outlives-with-missing.stderr @@ -7,6 +7,6 @@ LL | impl HandlerWrapper { 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 ea43dde11f80..96d0cb80a743 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 2ad39b000717..834d5c6cf5a8 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 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 a9a92b7a695e..03d5a0be7235 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 e96559937d42..250571f1556d 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 d95289f3f9de..7eb5d39ecfa4 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 fda66a2412cc..713252dbc08c 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 b86f6e3a2a12..e8960fcc6569 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 3d7aac74bd4f..75e1abdda206 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 2a2625203618..2a5831aad255 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> = 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 a96f5612fa23..6ffe416ca5f1 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 6193bf02f6d0..bd8640b9d34f 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 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 0e0086be9ea8..df37df99bf27 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 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 b6d7b8aac5f1..f1375404443d 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 5bfaeb295c35..8353587c6463 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 | | `*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 9f92c40e1e18..706595ae87f7 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 | | `*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 baa0506d04ca..a353ff89b80e 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 | = 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 41d609b56d23..93a0a1dc7c27 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 91cf57e099df..fee2b77795ab 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 a7746d8981e8..8c79eb222be8 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 eb4cd5ca72ea..5ad16069ab97 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 9f425125b989..aeda923b0ba9 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 cae6c33ac6e1..4d185e52d01b 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 8d82ff958ff3..2ccdd65f295d 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 1df7ca0e3e90..1c8f1c1e472f 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 d0ceaec3b67d..9025f0c3cbd2 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 575037a0a4d6..727669f26835 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 8c1791fc11d7..7d9f9121a48b 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 6844e8665329..1555e5981c5c 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< >::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 ed547aa9c410..86a6d33d6d35 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 992d25c9fd12..2679ef93b97b 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 8cfc44f6abd2..4c7660276f2d 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 2c7a6e8b5c0b..15dc1cef83cc 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 d0c4b9a57e09..7bf112dc7212 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 ca51555a0774..14d1ce7ae8b3 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 94b80852d012..56ee07bdebd1 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 f44a0fad59b2..013475c26914 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 c8c7808e06c5..2b17f74ad1b8 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 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 1165011c1f4f..9cb9dac4fdfd 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 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 f3973a93bad8..098a9c11de44 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 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 afabdc1de1c7..4a1cd111936e 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) { 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 c8a33bbc5223..919fcffdc531 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 53a5612d24f2..31dd7efe067c 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 cef73c18d371..8b0cc925a866 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 4b7026e65eac..6d334b498aff 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 43c8d1272c74..254497639a17 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 5672837290cb..2e76333e26f0 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 eba2a0d58534..1c270d6c366f 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> = 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 18aec29ad0b7..1d3d5e831c39 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 0abe77a86977..b2f63b3b8f27 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 60c5246e2407..3fe497bf2e99 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 (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 dc905d076bb7..40d4f1652796 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 c98ec477417b..fd23fce76c82 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 0784e894ea92..4ad526602df6 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 d9be5ef89cce..f16a4a2e8c15 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 0e4875ac9855..470b6ab06dd3 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 b087e03b464b..be9ffbe8d91a 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 9d87fe266b15..68631c74e779 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 5b0efaf95597..9324eb892a67 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 56c9f89e1f59..235950c2e0a7 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 c32bbe0ee1fb..b261f5a41b68 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 5352be430fbc..5e952ee57715 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 22c9b915bb9e..bb96bf5970c6 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 a07181ad553e..b544bf5ecb20 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 b35a2cb905dc..4695045bbb73 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 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 761e78d179e4..5945f9ba1ba5 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 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 f6006ca046a8..209961508208 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 1bf8e6e062f2..2e3ede46eca5 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 f7e4dcc9d81b..ebdb851b7a64 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 1a500257f48c..1e434d22b107 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 0703b76d6de4..8e9fa18557c1 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 941b6b7a68c3..3f9bc9149c24 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: `` -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 eb42349aff1b..1d6eb8ad6f5e 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 07fb5dcc035c..9eb735a3aab5 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 7d8293018d27..9900ade3d8e8 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>) { | ^^^^ ------------------ -error: aborting due to 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 072b88716ad7..6bb6e152c800 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 cd64dbb3854a..6daa6f5d7af5 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) {} | ^^^^ 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 b724da930dfa..378d9832a657 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 a8af0c7c9b82..869149d8d3c6 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 39adc0fde44e..418dd9ea6b84 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 f2293d28ea15..cccffdcbf541 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 370d4b14540d..300aaf26cb7d 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 dd29d7fc0510..05515b1b4605 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 e60489f5b82f..7b218694b269 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 d4d141fb06f3..87fa940ac3b2 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: &::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 a049cac830ab..5e87ccf41327 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 cf4e4759c370..ef1a6c919eeb 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 1a345d2a3e3a..da95029f6e78 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 d5b8c08ced7d..ad6cc6986229 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 4c864029c987..7e7ef22ae619 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 bd748211ed32..b58168d0e758 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 5820a189fd57..8880242c1956 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 ef59d00360b8..6809fd50f747 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 710002a154ef..914990c35ff7 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 492e3b34a179..3eba715188b4 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 d9006c0a6c26..511b8da716fd 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 9beb626623e4..3bd4c1a5d131 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 0dabdfd9b390..ed3eb2dfb237 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 5af14b1b68d3..482a3bd54a33 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 877cf68b5866..8ac8a6dc4113 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 aad1b583a324..e522e461efc0 100644 --- a/tests/ui/resolve/issue-23305.stderr +++ b/tests/ui/resolve/issue-23305.stderr @@ -6,5 +6,5 @@ LL | impl dyn ToNbt {} | = 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 42a7531c5b94..ced19ea1819c 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 d5b015eec350..5dc4f9542fee 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 e3692934b62a..0fa96a87482c 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 e3733cebba58..a092f562d388 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 c0cfefeb940f..7817ab40172e 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 56281938559d..e65b911151f0 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 52308f2a7f02..12e1b4b0bd3c 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 782cfeec4bca..2693daa3c7a5 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 70631a13cdf8..e9dc344496e5 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 5045ec6c30e3..857f6a735178 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 7626f827fc5e..e7d26d63be3d 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 558e6b7b118d..8eeb398f077e 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 d58b6ca5b5c4..25e98b4746b7 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 3e9c3fd11b74..363bb5564782 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 6668108d0245..7f1a1aa44766 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 a118f94191df..d1ceee3e56e8 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 109409d2731c..60ef13551a17 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 93e8c0341a13..e300ee964bee 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 d53599dcce61..3894b9573a45 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 5f55d9c241a5..d25c67825e3a 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 7a7b749aebb7..35585e4240a2 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 fffd3027afdb..08e7fe9a678a 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 5790e425c0a2..a7770e1e7e49 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 Foo 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 771dacbbb20d..7d2aa6911363 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 852b9c6afff3..36eb3148ab51 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 ea6cb9eb00d8..999e9a47d6c5 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 abf068a1f68b..e22e636adb6b 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 632be50f4c4b..de33addcb235 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 7b9fb6c63f67..1097dab415ed 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 5e5c9f6b3d8e..3b1b5f1ad001 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 198ef10311ee..c5cb4e078620 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 5729348ef210..4c93cf9ea3ff 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 d3574851d5c1..de65d695dd23 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 be5fb18a5d88..662b849da9e6 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 79d1d4883a13..d4ca6c6b75cd 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 3ec97171fd32..c4e50cdbfad1 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 35b2d0b323bc..5fa3703fdc38 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 d3bdfc93d492..b070439d72b7 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 0a11549cdbf3..09f3c50258d9 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 035dc9b9656a..e3de0a3fb74b 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 832aaacaf49c..165e100bf2f5 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 2029c6d9d81d..17567c6016a3 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 ed159298804a..7b5b032579a2 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 3210a67d4180..3c5583da6826 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 eb2322d51fd5..59a6bb85d0fd 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 0c1fb4d9c593..2eeed960ddbb 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 60d538eba882..1757fcac6e25 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 { | +++++++++++ -error: aborting due to 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 befc57563a9c..0ce161e24b3c 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 f08ba522a937..334bd7618ad8 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 012ccab176cf..58bfcbb451d7 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 623fd585accb..505b7d79cadb 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 46600e7b215a..729e747def31 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 1c4fb914688f..c2000df88f6d 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 = 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 6adebada0437..477789f33df1 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 f5b10f0626b3..b806046db142 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 d4410e147503..4218ef31e201 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 a6fec9c4e2b5..d931e23c7568 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 bee639bf26cb..ce145689f901 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 aca839d804fc..c208e050320c 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 409dede1a90a..6c3d576cfbab 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 40f736c215d5..3fbbfd0fd0db 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 5ee6d127e85e..f562b97c3446 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 7f6749fc9ccb..534599b74dff 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 53779d365f3f..fdbb0e6559d1 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 bc8fd92ce586..7ed17dff10c2 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 cb329548d86d..1b842c206ee5 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 a19750cc73aa..0a703367d969 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 04572920ee41..a9c9eb2a5cbe 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 fc06de90a003..1c8e8d5b0a7d 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 07991af6ef97..8f720daf11ee 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 e1e1bf7f6d97..84ba69703da1 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 c672acee040b..6000507c5897 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 5b51dc5acc4e..a83c58e70070 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 ad84ebe3a504..70f5b2b84d86 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 a61dcf8399f1..c8dad8b807aa 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 46093eb9fb35..2535e0518078 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 27939176f75e..2658b20a7269 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 f39e6ee29854..3034a67dc43b 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 e7ddf8df4ab5..e22d812c8b03 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 6d6562dae3b6..4626544a5cd2 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 b6ef6215275e..2738444f21f6 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 b36597bded94..f976b7f5210b 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 76300cce55cd..e2a92cf72d56 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 041f7ebc0aa1..b0f1d7b33e40 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 { | +++++++++ -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 595a5c28088d..30d1b3e77b1c 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 3059f95aefbd..afc044d88482 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 589e95899132..1c39c984a2a6 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 9912e36b29c1..4ec3087acffe 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 16b64bdc29dd..bbb48ef1f261 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 4350e6e8beec..b584d17ae853 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 c08add7edede..59df869c47a6 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 769555234437..7e5af7fe6ed5 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 a785c63ce3d9..bb0eea027d5a 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 d9342013f554..47f3458e0867 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: ::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 508114357817..329d5ff06abc 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 5dff4c8fffca..591585c88f5d 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 975776cddffb..0404b52d9efe 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 be05ecec0c9b..62415e250eca 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 4ba1778d6443..464d7968b740 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 9c836b190cff..8f8ee9205471 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 2b4625f77a5e..7fef81c26197 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 c39a70f66a97..771a09abedc6 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 81891572179b..1047dbe1063e 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 7df4f06d1c7e..e3875fd843b6 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 bd6778cf3d63..c321f3ede2d7 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 122e8fd350cb..7f989c15f1c0 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 b8e1bb324b1f..741ae7c92d78 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 009d153387e3..98285f5c3e1c 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 07e7c6a2c07e..31df8a922ace 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 00c1c303d2b0..b8065b9f5560 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 9dc339abc06b..c2b9899e20db 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 ce165e646329..7ec018a95cc7 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 18917fd2556c..06c6c9053389 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 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 e08ffe42d6aa..7bbd4e158982 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 e08ffe42d6aa..7bbd4e158982 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 cfafbd52286a..57ad1cc8d080 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 b49f8afd960d..d0a67c4f6a8d 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 a3e559054f9b..6af1d4533b7c 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) {} | ^^^ 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 1597e5be45f8..b2c1406d0939 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 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 5aade17cba52..cb663401e1e6 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 3eaccde3b745..606f808f0936 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 831731ba4741..61aae850a943 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` found reference `&P` -error: aborting due to 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 1c26eb8803d7..8ae7691a4848 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 593821bf9612..0c269a23f49c 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 b635a09afba4..ede20cb8c3f7 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 452bf757df76..8d809907a535 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 02d53cc78ee5..4007fd455f88 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 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 bea1846e79be..1f7cf689e958 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: &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 c8783de4c3ee..ae035b26ec58 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 f25390a9070e..fc9b5557a649 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 4c45b0e56c60..73ee0f2151a7 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 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 a8ef244ea309..33ae7131b928 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 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 7b558e3f773c..111a6a3fc7f8 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 f5147dc74b87..16ed615907b1 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 100d1df87d69..6f75924f0aa6 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) {} | | | 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 dfa5ea8c4afa..8997e7ade6c1 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) {} | ^ 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 8af38b792e66..09ebf55c57c7 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) {} | | | 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 be75e852e0ac..5c0f19b5f14c 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(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 be75e852e0ac..5c0f19b5f14c 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(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 603f6b7d2835..efa72463c5e9 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 c45af1a9f8ac..f0b6e2b1c255 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 cc9bdd2715f7..2dd96f548fed 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 1c69ad431714..dfe8fa79e264 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 37d123e4ccc4..3a8c4833414b 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 428286e0b12a..ed647aee8c37 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 22f13a7416e9..ab039397edc2 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 a6881b8fed51..d8e2c0ffb813 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 002d586ac64f..413e217020d4 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 4c630d33c551..663cdd1fe57b 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 6a177592b645..1e8a70ffd291 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 const std::ops::Add for S { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = 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 6d2be1daa372..90f30ea635f1 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 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 0a91719e1f15..4695728f8caa 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 6c6ca9f5db82..36c8163f1c56 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 f0c61cf9dd98..077f6c7b2348 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 082c0333fbfc..85996c212118 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 d8cb10c65174..157b54214fa7 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 b27f94f99ed7..2edaca606235 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: 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 4fe8a372e070..89e59e5db6ed 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 c36142dac928..5431116a1a70 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 979d7febbcaf..97ad83130d44 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 cfdda4713a79..b2e09d82a905 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 const Convert for A where B: ~const From { | ^^^^^^^ -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 24766804708a..e356621ba47e 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 4734cee7f9a1..68eac990aaab 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 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 92bc9815e963..0b35feddc553 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 | ::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 08258fd1a572..21e21c2cb71a 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 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 d7aa0d95cfc7..1346c4c4ae29 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 78aab9469e82..bf53b995bb67 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 6a3396401d2b..6d624def2769 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 06330958b8e0..bb206d50b74a 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 5d34156a5196..1faa5b4dd2c4 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 d81d9aa94da3..5cccc025161b 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 ce74ff8dde75..5850ab41c6ba 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() {} | ^^^^^^^^^^^^^ -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 928d23e8a424..a809736a4f82 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; | ^ 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 f77672f3e71b..0925bfa7e576 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 31300354a573..646cdfc78f97 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; | | | 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 a17024c5310d..92f22d780005 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 d15caeb66981..85452ea41d31 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 8a9179cca6bc..830169e032a1 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 a4af319e339d..af11c88d9282 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 992b2975009a..b413c0fd9ba8 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 b6f5b10cf03e..6f9a5ddb14fe 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 bb50ec3f57dd..a68d99c14cea 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 eb040f5de544..36986c89c62b 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 1a9aa75787a3..85e26d72a673 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 9933b92439c1..49736205f204 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 2ef97e7f20e9..801d16af82db 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 666864a18af8..e726b1e3e818 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 a5c79366bf0d..f2536c1a1e98 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 8045f3a45b60..3400183df6f4 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 adde63590351..7a1c55a8b2b9 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 849d6275eb85..363d7a7a25fa 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 ac2baa3595bd..4a874a834bb7 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 ::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 8a978c98a443..661d667eb9a5 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 97d4c736751a..a0d272dc658b 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 09e9edc638d1..b6bf109824f7 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 9dfaf13e2ecd..d2b2e5b2fd77 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 de27e9b8f086..67451195b64f 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 c687d186989c..340a8e22482c 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 e9a4c1dd52f4..bf104f48be0e 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 5ba09a2eae1c..a9da75c0171c 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 41518295b122..df0c4cb6b631 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 d61eb3816479..5f535206d267 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 5920880675d7..0f5665f1fb9d 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 2d5e537973ea..2d96c606b163 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 9f74235fea5d..98b0ed82e80e 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 f86db41bac71..4dff813ee1be 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 3ee95634b16a..de67d6a6b7f0 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 6eb09a53b486..621708de241c 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 e23bafb18146..b9e9722da230 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 e31642054343..748fb60dad92 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 8cd9c544417f..efc0c43138e1 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 136f49360849..8d6dc1d8f1ea 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 ab8f4f4f3515..0da06b7f8b18 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 9bb8405020d7..bebbf3884ae6 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 cbf5e6c541a3..a415aa3d7b49 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>(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: Rc`, `self: Arc`, or `self: Pin

` (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 7378d53c3738..44e553f1a06c 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 0a567ddcc2e8..363ba072c816 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) -> usize; = help: only type `usize` implements the trait, consider using it directly instead = note: required for the cast from `Rc` to `Rc` -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 5dcb5861120a..f33b9ec68b97 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 944cdc5f55de..e04ec8bb3bca 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 8a9b397ca700..a2964881d58a 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 6faa4477d8c5..7d5214421e32 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 3c7cccfc9a16..14bd6ca6b014 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 366c14f7616a..29510190c814 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 2beef50cdb5c..9e140e21023f 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 1af0400c8861..0bcf32790bcc 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 e7b41cd787cd..58e2b7c83476 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 fc66b195674c..c4cfca7be1d5 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 b334b1f4b589..fc294607ae31 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 9e8f06b824cc..249a14098c33 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` 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 a2dba1222eec..39ff36799cc9 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 3888e7a0f38f..7ac8d7153603 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 7f23893ac853..35297e17d370 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` 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 51d3c0050720..d2ce0fdd2024 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 94129560f404..e151269d7312 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 69578fe2f883..bc86e36f308c 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 1a6e8310d303..0e67180a8ee4 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 { LL + fn next(&mut self) -> Option { | -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 4794566eae4d..4cc46524a925 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 b6e42d3e717f..554a19afbcd3 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 06c87b61f41f..21e54c12feda 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> } | -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 0f72f74145e8..4e7f40a01533 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 af306685021e..7c3276032c2b 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 1323524f2085..416873a42572 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 20f2e0df05ef..c8599b4ebe51 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>, | ++++ + -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 9db627562d6e..0f2e2d7b3fb8 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 b1411bc436ae..9060b687f508 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 820b0d7441b4..b0f652208c4a 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 5478c3fbcdda..4254d3893b83 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 3f033f5e47b5..39e7279fb77d 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 929878026290..d4a8ba2698da 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) { | +++ -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 25e344fedfb2..c0edeeae20b1 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 b923cee5f0ec..a80a89fb632a 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 1ec8ca4275b3..004a057bbcda 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 097fb6219f1f..6e05f901ab24 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>` -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 c8b8f346b987..5376d7799aaa 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 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 1d317fc331f7..c7f9573593b7 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 d9cce2254dd9..45a5d7dfbecb 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 cd854e61f2f4..6baec60d50c6 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 83a9e8c9b987..fe7c7794c9c7 100644 --- a/tests/ui/span/issue-23827.stderr +++ b/tests/ui/span/issue-23827.stderr @@ -6,6 +6,6 @@ LL | impl 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 cf666e8b4a7a..609991f2b5b0 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 c3b6d7580b4e..f7564f8c72ec 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 83db4d509d49..2252a241b73f 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 1e0276f0c369..7a6910065fc3 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 fea6e001238b..586eca25473c 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 8a254a968554..c2de1562841c 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: Rc`, `self: Arc`, or `self: Pin

` (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 7d603cdbfe5c..c78287546909 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 8cece07cd48c..29490d86fffe 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 88c86d2a91b5..4c4b100da3dd 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 8dfee8d644be..eeb4e9a0e4fa 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 2168767178d8..7b2ce292cfc5 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 86e2d8c56b08..7b8af23a6cd7 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 94c450c7b1ec..4b66dc76c443 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 e133f75d57bb..fe43657bd400 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 9ab3cdd1343a..aafa29e5eae7 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 2127b8202056..2e9cef32e7e6 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 fc2f6e6622c2..9e675d56ee59 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>, | ++++ + -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 b6052a209bf5..f0eec632aa1c 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 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 395b6ec67918..1624b80e7221 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 25c09959047a..7da9e32b31f2 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 10af4c36ba4b..30ba8cde463b 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>, Box>), | -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 9b5ec84614cf..225f83b6e666 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 81e858fa0ce0..b7ca491f22cb 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 fed40a4fdd2a..3849b9eef08f 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 e5c7d8b26ab0..e32cc10c00cc 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 47931db84cab..746be0456082 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 b271c9ae6f61..48ac20feea72 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 21f8bb62a0c7..6e6e31a5698b 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 4dc3e5721160..c0f3f3a65c78 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 65a90318a3c2..a548df052b82 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::() 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 cb0aefe06090..5df74fa2fa2d 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) {} | ^^^^^ 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 64c2d0f16066..09d6714e777f 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 e498187c0a11..516df555a0d5 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 4dbe251ed5ea..e02a945d9a9b 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 X for T where &'static B: PartialEq { | ++++++++++++++++++++++++++++++ -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 c597eed37909..afdbe2eb2267 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 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 64e14f5800f2..18edcad0a47b 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 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 f19975060a46..d3441b0e8b92 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 37788612f437..75c91e4806f7 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 e7801603493d..01188e293bd9 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 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 27ee42fc00c0..ed392e4f9152 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 78e94cec2c0d..2c20077078fd 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 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 5a05f9c270ab..828a8e933994 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 4d840482b46b..eb64383e18bb 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 9ce51d1136d0..dc5db4f4285c 100644 --- a/tests/ui/specialization/issue-39448.stderr +++ b/tests/ui/specialization/issue-39448.stderr @@ -30,6 +30,6 @@ LL | where LL | U: FromA, | -------- 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 26db9d7c9974..271135092571 100644 --- a/tests/ui/specialization/issue-43037.current.stderr +++ b/tests/ui/specialization/issue-43037.current.stderr @@ -7,6 +7,6 @@ LL | impl From< 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 26db9d7c9974..271135092571 100644 --- a/tests/ui/specialization/issue-43037.negative.stderr +++ b/tests/ui/specialization/issue-43037.negative.stderr @@ -7,6 +7,6 @@ LL | impl From< 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 1941d40fee8b..d184c4468b68 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 5013559b80ea..da0dff78e263 100644 --- a/tests/ui/specialization/issue-45814.current.stderr +++ b/tests/ui/specialization/issue-45814.current.stderr @@ -9,6 +9,6 @@ LL | default impl Trait 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 5013559b80ea..da0dff78e263 100644 --- a/tests/ui/specialization/issue-45814.negative.stderr +++ b/tests/ui/specialization/issue-45814.negative.stderr @@ -9,6 +9,6 @@ LL | default impl Trait 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 3fc29fff230a..7ac4b39993cd 100644 --- a/tests/ui/specialization/issue-50452-fail.stderr +++ b/tests/ui/specialization/issue-50452-fail.stderr @@ -19,6 +19,6 @@ LL | impl 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 cb46db83606b..9553a04c8f6b 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::<::Type>()]; | = help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<::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 85aac16f6d03..3b0cac514643 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 e8a12e4d928e..60522e0f587b 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 833f61dca8ca..0ecec03a023e 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 83f311efd39d..def4a413af11 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; | ^^^^^^^^^^^^^^ 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 b032ccbe53ff..85b492c0503b 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 934103d49dc0..553bee2d2dd9 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 a751ba793472..01fd04dd3d02 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 `::This == (I,)` LL | impl> 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 16dccb10b453..d80ee7b579d0 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 5e6adf723b54..90ec4b945e05 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 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 ba9d6bbe3001..42c0de85e52f 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 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 e935786624b4..1fc064a0a3df 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 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 65f73781cae2..8e7dc9c5ef3f 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 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 9a16798f15cd..8c2bf6c2da09 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 7b79c7eb4ad1..c86b4ac3915c 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 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 cc12302bd8cf..1686f6f0cd67 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 Z for A {} | ^^^^^^^^^^^^^^^^^^^^^ 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 578db0cc65e8..e9498a003179 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 ::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 578db0cc65e8..e9498a003179 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 ::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 42dbb200c247..35e5e3bc5125 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 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 9157ad0d46a1..f42289fb9628 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 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 81efd46cc7fa..b143f888f235 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 1fe4869ff548..a8e99953e2b6 100644 --- a/tests/ui/specialization/specialization-overlap-negative.stderr +++ b/tests/ui/specialization/specialization-overlap-negative.stderr @@ -16,6 +16,6 @@ LL | unsafe impl Send for TestType {} LL | impl !Send for TestType {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 ff733822cab9..f85b3c6eb665 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 132c00b89b22..f09289bfb898 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 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 6d8b01a54952..232de41c769e 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 8ef5a364ecc4..0a5f58288fa3 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 f6a099cd25e7..050834ab6760 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 063856676582..50cc14c3b4f6 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 61253adc892b..ce34f96771c4 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 Trait3 for T where T: Trait2 { | = 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 7e53bb54457a..e16eae88b01d 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 d2e46683b903..0fb62ece3136 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 c7ade234d3dc..3af1e82d207a 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 ff1856f1763f..63890092ebcb 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 c9b3f07cc70b..d783f1e8e404 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 9a5c7ef5a476..4940650fd426 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 b1c56ef224ae..a6d1ebf29458 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 cc8758714fc9..9eb4d3efc8bd 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 11d6abcaf361..51780d208809 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 2e930f4596e0..807cd2f7a25a 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 4fc3ca78f961..6231a276f991 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 035be2b1202f..1c53abaa2950 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 99235e26e15e..b11c0b5a530c 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 235e9ee9b919..1361e7089e83 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 19e55a6582e8..8b0d3a0bf4cf 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 4af3370c7994..8c9434ce3cb0 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 4be1b22fc6b4..3c77b9000fd1 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 983e1026f91e..f71701ca7a40 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 8411a1557b4f..d125bec59435 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 = 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 86c4eaa7eb43..ce9b6a739cfc 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), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -error: aborting due to 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 1a607e3c014a..a47c94571022 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 dec0123184d7..db0c7eb8d35f 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 8e7a2514dd6a..ab50b97d63f4 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 8e7a2514dd6a..ab50b97d63f4 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 bc6e45e59258..96f894146c5f 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 2d29dec888e8..3bbcfdd85347 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 c3cb488e3d1b..44ec079e9291 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 bd354679f788..85a1db8adcc8 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 e0a8225507e5..e34eb04bc04f 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>>) } | ++++ + -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 ecf072b8e8ae..792ef4428e3e 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>>) } | ++++ + -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 4665ebf89a3c..2334e5e9712c 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 7ea620f386a2..4253fae03c07 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>); | ++++ + -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 be25b9091d58..d7464dc56a74 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) | ++++ + -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 858a8fd6af80..4ed1c1816eac 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 } | ++++ + -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 a1a81e293677..9358060a87b3 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 { V2(Box>, marker::PhantomData), } | ++++ + -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 2f3a150e5cba..664a00e3303e 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 e3af8976cee9..b28c3de24179 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>> } | ++++ + -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 39a99ec1ef73..cdf51632acd0 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> } | -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 394134c78556..e788b2ed0f8a 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>> } | ++++ + -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 3d141e44babf..3208effc0003 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 { foo: Option>>>, marker: marker::PhantomData } | ++++ + -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 44a90a6fe389..1b943bf89569 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 { x: Box> , marker: marker::PhantomData } | ++++ + -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 f1d50bc8af5a..550b078a6a29 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>>, | ++++ + -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 536f54e3e961..2d971cfc8b6f 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>, | ++++ + -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 0d12ba9c9168..15850962bbc5 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 1c7d52b6d605..9930efab730a 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 ba635ab1fe67..a0bcef6b0310 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 8bbd3ace7d29..5b4b532fcaa0 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 834b3c5c1716..4ac3fc9fe6b2 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 d7ce9bb89226..3c25708a3de1 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 aaf2533dc011..ee38743471f6 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 e109980e0bba..2b88d802833c 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 ed3650e5298d..8217d7a6e811 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 b3e42a94809d..eba095fd35a3 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 09fc4f7ee586..b485c17c1b27 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 d89d45b39033..c4d804aaf9d8 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 9342607ebce2..838917474e6c 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 aef0e0e8e5ca..d87bace72773 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 eceec65e7634..4fdd47a48065 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 5b01208c56fb..621496bb4300 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 a5796a222256..9902c3ed3571 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 67a84f119f6c..ea474e321253 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 e2129b4502ab..5432fcb1a581 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::::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 78e5634b2de2..0f58ce65049e 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 d55d968b600a..69e9af726479 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(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 05528d277be5..5a9fba8a0e47 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 df3828ad411e..f83da7909700 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 418690ff85fa..d96ee33a9146 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(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 e0c57af25b3d..6a232c3444d9 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 + Send + 'static)>>` found struct `Pin + 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 1adbc05406cb..c5fe9630b9b6 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 11823ff09d31..08fa1a698d6d 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 58612cbfb239..4124a0061726 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 167f7e592a97..f20596a80a6f 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 90f44cce06e4..f804c66aafe2 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 f344ac06db1f..d4056e09cc36 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 9ee3e6eb2c82..b6c286128023 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 9b92091de9f5..96f1f8605886 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 48ee44a74f2d..c2634e3070ea 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 2298e7f4e0c3..2cd3fba87154 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() 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 0372a7e6cc0a..a2b68fa966fc 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 9d843c2514b9..eb95f729d1e7 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); | +++++++++++++++++++ -error: aborting due to 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 c6867270ad81..46613e8e1b48 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 866d3fab46e7..00d001f6bee2 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 = 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 f8029e452bb7..ef08282702e0 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 = 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 c66da3ea6d97..8f738465d38d 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 319d866003ba..348f7e00d468 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 0d9543e0b8fa..6aa187bfbd3d 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 85fbb8b88e81..974aedd13cf5 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 f76019b70001..6d72dabf70ec 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 cbf6f3d10025..2b1f45923836 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 def16401750d..daff2db64189 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 9dea667fb961..47a7ac895bf6 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::; | +++++ -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 fc5a521746a5..2733bbff36b5 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 f7f7902c17d1..6cd21fcabfaa 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` instead of `&dyn Iterator) -> 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 20f8e65f769a..3a6052448cb0 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 7e24150e7f44..d6efc8173cb7 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 570afcea6434..018250c8c1b6 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(s: S, t: S) where S: 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 9f77ead42944..8a7ecc801784 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 2656ab3db0bc..ececba5fb1ba 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 2aec3c863af5..0dad813b389a 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 9f00de17484f..4de91a1b9950 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 151587d42223..c19cda20402f 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)>` 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 08d4b9955903..8340d9340f9b 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 4ca7fdf9b5a2..b7de57bfd90e 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 3ae9813d4914..8d0e8652392d 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 acec3a55d526..325b6b6eb4b6 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 b31b84781bac..a59262183412 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 895f5ffd1e1c..f717f8f4e657 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 92e3cf8c43b3..4be495da46b1 100644 --- a/tests/ui/suggestions/issue-107860.stderr +++ b/tests/ui/suggestions/issue-107860.stderr @@ -7,6 +7,6 @@ LL | async fn str(T: &str) -> &str { &str } = note: expected reference `&str` found reference `&for<'a> fn(&'a str) -> impl Future {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 644841fdf7ed..c787be4de7c5 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 c479326f9353..4425ce84b6d3 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 621a3897165b..52444cd4c45a 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 67462a09c78d..d2a7806b7c12 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 f09675fcc5c9..01783ea4ef62 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` 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 bb8b9b37067e..3c3bc2305e07 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 cda962a90453..890950b1ae9d 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 ead8f18547b6..f3a9f6b7913a 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 d7b33ea41f79..ce0087fbfcba 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 7f931f0cdc9e..760f83d548f0 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 80be252a0a51..235dfcd3a2a5 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 f257bb9b0e88..f0680dfe19f7 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 238ee637c7d4..de1ea98554be 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 5e471819b27b..7dbffcfca4ed 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 c73667f09cbe..1a085368485c 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 70c96feb1de4..fe0a7b6731e2 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 513bf28fb587..74995a0500ac 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 55c89884a5f6..c5e1958e030f 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 752533cdc121..21b568b02ad2 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) 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 92be9f764cc4..77e5dcd91a1e 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) 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 4947269d7593..b4f0793c225f 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` to implement `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-89333.stderr b/tests/ui/suggestions/issue-89333.stderr index 4739f11ddadb..761de7f25218 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(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 8ff4ef4f0ecf..3252cd6bba4f 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 7d1da7d24eeb..96fb1f3c68da 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 e1fb479a3a7a..1a732ecaf944 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 d4e9433dfda0..a54a4e7b3be4 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>(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 575d79267f20..0e95167d8515 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: 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 ca017be45ac4..a7284db1d956 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 5415c247c8ff..c3cf7e13987b 100644 --- a/tests/ui/suggestions/issue-97760.stderr +++ b/tests/ui/suggestions/issue-97760.stderr @@ -13,6 +13,6 @@ LL ~ pub fn print_values(values: &I) LL ~ where ::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 e7251d735e38..aa66a9aa1e7f 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 7897fa441a24..578eb284c266 100644 --- a/tests/ui/suggestions/issue-98562.stderr +++ b/tests/ui/suggestions/issue-98562.stderr @@ -6,6 +6,6 @@ LL | impl TraitA for X { | = help: implement the missing item: `fn baz + TraitD, V: TraitD>(_: U, _: V) -> Self where U: TraitE, U: 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 d1908dd9d0d8..9c385a7a408d 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: 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 a2b559784784..00bffee65293 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 f1bea688b4ed..ea819067a23a 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 bdf2a07c143b..e1d7aac267c4 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 6adefe3de371..9ef28bc26159 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 a03d4e8ce9f7..d78de6a460c9 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 6c63e1ada613..2677b7943ccc 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 7b126c90ee79..00bc43d5e464 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 dc5817bfe0f5..73fa5ddb146e 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(value: &T) -> Box { | ++++ -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 e36919c82f83..feddc7d62a75 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 -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 4d44d893a86d..93024b1f0b11 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 4c2d2776d3d8..3cf5c6e7b749 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) -> Self where T: 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 03082be690fb..f9db1e1ec008 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{ | +++++++++++++++++++ -error: aborting due to 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 09696e0613e7..ed1bde5f83e5 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{ | +++++++ -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 8585fe47bf34..03db737fa876 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{ | +++++++ -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 856d8db381bd..6dc512223d1b 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 Copy for Wrapper> {} | +++++++++++++++++++ -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 ec3e4f23a649..fd38d4c64b44 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 Copy for Wrapper {} | ++++++ -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 3116c5a0a1cd..d667fc36539e 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::(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 bfdb35947ef5..aa11bc7cf1d9 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::(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 68100e56cbc8..384b17d1e2b4 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 b294f4da7db3..278bfc60b55f 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 5c90d3012abf..3ce45c7b6745 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 97d05d9dcffa..63314acb87cb 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 94acda73c4ef..0297c031ecca 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`, 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 e042f07daeb1..e16d829ca7a8 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 fd3646b8c3c6..567d9d5b9e7a 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 0db426588bd2..0d73af03865f 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 40b9cf2dcd4d..bdea727a0981 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 3c7d42888d83..6d9780a871c5 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(a: Wrapper, b: T) -> T where Wrapper: Add { | ++++++++++++++++++++++++++++++++++++ -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 3a1a0f7f4f54..23de2309e877 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 63fa9e040874..604704904410 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 2956360980ec..088da83f589d 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 33824c4cbc75..3e49716b0315 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 9c0e6e265690..8dbd94208d61 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 80ad3f9e41bf..fda5ac4e4f07 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 850f69f2d985..be458f3bd53f 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 00fb96f03266..a30b78692146 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` 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 c247e73b39cb..6e4c77deac50 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` 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 7c9f0b6c212e..1bc259294469 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 e5d5ecc0be27..58f8774fe9dd 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 f4c2eb7ff34a..be473d3cfa28 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 88bf263043d2..f6c2a79b62ba 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 bc4107528d27..d02e20eb7b74 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 23f6657f092a..2316acbe9da2 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 347a038525b6..bf7790e2307e 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` -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 3fb3047d866c..866162bab01e 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 1660db1aa83c..de2485b7be0c 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 8a2df8d7cc1a..0bd286e0a622 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 c442ed6377a8..1be14aa8f55d 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 3eb9e1031d70..37bb25b300f3 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 1220cf650cc3..a761a454ad5a 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 387770535f68..523f78dffcc6 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 1632b2abb2f8..bbe3261e1486 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 7bf421a7729d..a3e142563ff8 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 e4ad17e06716..ed9fc2dd2568 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 352f6da3607b..0da0241fe82c 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 c5df72c4a477..12da91c20b3c 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 bb185138383f..c42f09e3201d 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 0d1eed67c55e..c0f0c4142273 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 Foo for Bar 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 1214bec16ce0..8a79745133c9 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 eadf634bb14f..4efddca4b471 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 065b1f4d3538..939990d74405 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 b3799101cf0a..3242b028d5d3 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 -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 43d00591e74c..ba0682cda321 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::,_>>()?; | ~~ -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 849630218dae..566b036e53e4 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 -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 11d0f5f527e2..6fea7f940523 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 -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 39169dfa9f77..a439546492b5 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 77724e7e2a47..562e0bc3fbc1 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 e900e12b7df0..d8f2d58a2487 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 23613df6752f..4dce81fbef43 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 caefdfc96f03..130042e34ec7 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 5e890c6aa579..b4d64a78e96b 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 dcc250d5216b..7cbbcca993d0 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 2035993d218e..b06b4a9617b5 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 eef85aa95461..c3e2b436fe1f 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 247f74e50df6..34602405dd10 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 78b54f227f0f..94c2d9f15c5d 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 d8a81864dcaa..31c16973b30e 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 6e1bbf701d77..cc5767474002 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 0c3205e0108e..36f080b60836 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 4dc5571196c1..1501a793d5e8 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: 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 20242f4b61c7..8a9446a09b9e 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() {} | ^^^^ 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 ca3ae77b1a05..9ef8ddc18cda 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() {} | ^^^^ 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 5b54880a6855..49ecf65b7e62 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) { 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 ae2f5a7aead5..560dd7e8164f 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 10dfd2de744f..0e470a7b4057 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 0ec7427c3c45..b3bd12600f8d 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 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 b4b50d98192b..bf211fbee2f3 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 b4b50d98192b..bf211fbee2f3 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 b4b50d98192b..bf211fbee2f3 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 bd604afb79f8..6ac79924d805 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 e69932875555..6f5e3ae6b63f 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 2a3d0e3457b0..bc84ff413dfe 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 9c65c7360c10..c6aeb41f5acc 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 6c0f28841284..1c58e3885a05 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 e5dc0e72edfc..9001de34adfb 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 743e4b658c6b..a181aee6b581 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 98ad109a07e8..f2da61727228 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 16f678144a37..7d80e0728f78 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 fe13e5ef3f54..dffa0b0c91c1 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 9ebf222ee342..d9eaea93638d 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 aa54f92b6c02..ecc7d81b3c36 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 583b02555b45..8ca56d6db216 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 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 32f6b00b20c4..9a3bcaa0c4aa 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 543ceac8e917..84c2ab68da95 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 f08d685836ec..c597ad0b572e 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 30bb4a0a8509..a97daece3b34 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 61132efc414d..5024ad21892a 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, 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 4547e1c984c0..e2a72697501f 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(pub H); LL + pub struct A(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 38679679cf93..c1f31e2b32e2 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 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 e47fe1a8026d..cf9b4f2ae791 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 203bdc526f6d..034e8a3fb7b9 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 247a4f812807..4e2edb474c06 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(a: &dyn 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/impl.stderr b/tests/ui/traits/alias/impl.stderr index cedcd10213da..ff463f479379 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 39f974f962c2..968ad2667a21 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 f1b259d5a652..74526b4dbc18 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 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 E0599`. diff --git a/tests/ui/traits/alias/issue-83613.stderr b/tests/ui/traits/alias/issue-83613.stderr index a78294da6c14..847fda417766 100644 --- a/tests/ui/traits/alias/issue-83613.stderr +++ b/tests/ui/traits/alias/issue-83613.stderr @@ -6,6 +6,6 @@ LL | impl 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 61cc217cfbce..3de31b64c8bf 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 80af4e5aae33..ffc0a00ad7d9 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 6e03eeada499..afe34a125b20 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; | -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 7172008d3eea..3be6e8a49d69 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 = 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/as-struct-constructor.stderr b/tests/ui/traits/as-struct-constructor.stderr index d06e85f3a203..42353d210b44 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 7fa1d2c2eed6..2f07a32aa223 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::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 fa7a8a2a0933..e7e55d0beeeb 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() { | ^ 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 68b9319d65c7..b7a7784755ec 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 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 c7af71a42143..77072656c336 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 4891ee9c29f7..5cc38e4371d1 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() { | ^ 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 00fdb3753461..3e9e6dcac91a 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) {} | ^^^ 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 9b0975e5ed3c..0e2a32735e96 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) {} | ^^^ 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 4c2d8e9f050a..376a83e58a7d 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() { | +++++++++++++++++++ -error: aborting due to 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 f30fe12b216d..c8631ed3677e 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 36b08a7d3093..1d97bf3d8f95 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 372bbabbd862..48c3688a0446 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 { | ^^^^^ 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 b67648c7b04d..3b3ab1e995c3 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) { | ^ ----------------------- -error: aborting due to 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 7cd75819277d..e84ebc91ae16 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() {} LL | test::(); | ^^^^^^^^^ -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 30a3c40db95b..26136c6f72c8 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> = Box::new(Struct { person: "Fred" }); = help: for that trait implementation, expected `&'static str`, found `isize` = note: required for the cast from `Box` to `Box>` -error: aborting due to 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 ae70202ab7cc..576035f8c13e 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> = 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 7e676c9da011..750140c017c2 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 = 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 86c511c08956..3bdb8b70172c 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 Copy for 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/copy-is-not-modulo-regions.not_static.stderr b/tests/ui/traits/copy-is-not-modulo-regions.not_static.stderr index 130425211841..56544dd4def0 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 aee41c43aefe..4f9615104cbf 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 5a4dd1388b2e..7ad10cfce984 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 228bc3e35c21..cb7eb1567c81 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 8ca3d3a057fa..0dbf8f0e668e 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() {} | ^^^^^^^^^ 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 8ca3d3a057fa..0dbf8f0e668e 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() {} | ^^^^^^^^^ 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 2185c51e59d8..460595dd961e 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 | as Method>::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 6aa88d0dff4f..06232772678a 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 8ad11c3344a1..8bfda71bac1f 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 + ?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 45bd533b5c6f..955e2d780498 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 Generic 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 7694e3f5cfae..8c290addc7b6 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 bfa8213abe76..61302bfa0888 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 { | ^^^^^^ 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 910ba3510641..0f73f5ca7dee 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 6ec4083b513d..b715c699e89f 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 252b5aff96a0..2655d465f236 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 1bace8ab2864..092776edea77 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 7ab2864a8cfd..b34bb0361f1e 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() {} | ^^^^^^^ 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 e3b4ec07d236..b9a746e44ba0 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: 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 b537ecf17213..f2dccbbbb2cb 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(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 8c6e3695905e..f2e5e9080b16 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(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 edaf08f490f1..146ba16397a2 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 1f767a443d0f..f53c95c2b677 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 | <::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 203cd0630ebd..9fe508646423 100644 --- a/tests/ui/traits/issue-28576.stderr +++ b/tests/ui/traits/issue-28576.stderr @@ -15,6 +15,6 @@ LL | pub trait Bar: Foo { | | ...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 6b5b721384cb..2bf365745a6b 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 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 c57921a08aab..c37dde90e336 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 ae33e61d83b7..22b5af43ba9f 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 : 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 8f01d7c53e77..3c327f9edd51 100644 --- a/tests/ui/traits/issue-65673.stderr +++ b/tests/ui/traits/issue-65673.stderr @@ -7,6 +7,6 @@ LL | trait Alias = where T: Trait; LL | type Ctx = dyn Alias; | ^^^^^^^^^^^^ -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 671a97666fda..8bc315302417 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>::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 1c0e8bcf1851..174936631728 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` to `Box` -error: aborting due to 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 79eb7a2ae8bd..2452731f19f1 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: ?Sized> DispatchFromDyn> for = note: all implementations of `Unsize` are provided automatically by the compiler, see 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 ef55796187ee..2c03c6bf08ed 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 c7beb834b57f..58266e1842e2 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 1675edc9ff0b..137985ee0464 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 Send for 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/traits/issue-79458.stderr b/tests/ui/traits/issue-79458.stderr index 08f7bbbf0eaf..c80efbe92872 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 ae214bb9e9b4..8882097af339 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 9e80497ca6e9..1aba41833484 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 85d903fadd12..13568179e81f 100644 --- a/tests/ui/traits/issue-91594.stderr +++ b/tests/ui/traits/issue-91594.stderr @@ -13,6 +13,6 @@ LL | impl> Component 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 4593fa2c4857..c4324f0f0a87 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> Iterator for IteratorOfWrapped { = note: 256 redundant requirements hidden = note: required for `IteratorOfWrapped<(), Map>, {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 ca7bacdbf41b..0bb0b2840e5a 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: 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 9062a0fab630..2c6cfd83b957 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` -error: aborting due to 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 4315056f2065..b19b5d2e1dd3 100644 --- a/tests/ui/traits/map-types.stderr +++ b/tests/ui/traits/map-types.stderr @@ -7,6 +7,6 @@ LL | let y: Box> = Box::new(x); = help: the trait `Map` is implemented for `HashMap` = note: required for the cast from `Box>>` to `Box>` -error: aborting due to 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 e11799308c5c..d19f0bc086b2 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 d58f1e2d9e59..0bb095fb0e13 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 e3bfc78bb08d..17c3db9ad33e 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::(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 23e182738f70..420ed2dcd2f0 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 b253fbd0da7f..a232e6d8619b 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 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 7b54cf542220..328e744a1e39 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 1cfa49b20f35..97727da76f26 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 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 9f9e28678abc..100f97aba93c 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 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 040d9d14503f..36436dfba9df 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 a87acb1fb097..4778f31ff3a0 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 9185e8f8430b..95d7f6ba912d 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 545f94143add..1655cb05019c 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 !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 46677a583160..8c6840f72a7f 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 Overlaps for ::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 414deb47727e..4bd55ee80c6b 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() -> ::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 44097b556fc1..ebd0ada2604c 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) {} | ^^^^^^^^^^^^ 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 4aefdd6bb073..ac05dfb2d46f 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 a7d8201747a1..4cb41e7d5978 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 4eaa259617ba..08047852f203 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, T: Tuple>(f: Option, 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 41bf68a1d9f3..4e93ae284969 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 Trait fn(>::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 5d5f325e4b47..e3c0dabf549e 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 ::Assoc {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `::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 4db6e22e57ff..163710706b04 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() {} | ^^^ 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 1ac0e297729c..05aaf6108f1d 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() {} | ^^^^^ 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 f1871ff0564a..d4932191791f 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, 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 4cbd0898148a..7b3075f4ff35 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>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 57227321a6db..acacaf6a331d 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() {} | ^^^^^ 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 5a7459ec1fde..576ede52aff2 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 a31bfd9589b3..076dab29d890 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() {} | ^^^^ 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 6031d4f08ee9..91dd3ebc31b0 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 9aa4f4531f95..b2a523ba6205 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, | ^^^^^^^^^ 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 54965dee184a..e3be2931e123 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(x: A) -> B where dyn Trait: 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 f482e8cfaf96..c1a8b74df082 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::(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 023efc41aeb3..90b54b1e7898 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() {} | ^^^^^ 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 ebb03d84b871..67616619384c 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() {} | ^^^^^ 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 215a81cc2657..4b624fd0d354 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 e14953f19ff3..69999c755228 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 a3ab7836c193..2e3c22c8d384 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 b311ac6b5a61..dfff9f11b875 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() {} | ^^^ 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 072ac32a5de9..4be90c702a03 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() where (): Trait {} | ^^^^^^^^ 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 7d16aaa9a16a..00ba1ef678f4 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 = x; = 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/no-fallback-multiple-impls.stderr b/tests/ui/traits/no-fallback-multiple-impls.stderr index 61c9e5aaabdb..e38c432ca98c 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 ee7bdf282b74..fb7f26bb7666 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) {} | ^^^^ 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 07e02d47f27f..d5f2bfef1926 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: 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 d65892ec6dff..4e0441c1c7d0 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 [(); 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 a985b1a6e12f..1f13207e33ca 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) 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 da09343fb276..8cf32c89416a 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: 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 dc54e1acc392..cc482887c814 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 [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 d985386423d2..eecf8e88fb64 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 ::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 1124076c23c9..830446915091 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 Trait<(), Assoc = impl Trait>) {} | - 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 95656f99976f..2d330f6b1433 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 Test { | ^ -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 3b17f7697b2b..fbd723a1ba6b 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 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 e6c36129b285..7dd383b1e7a5 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 31441ef4db86..b4f00978ada8 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: '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 ddb6a7987113..3a4415ed23ac 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: '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 bfcad72e3527..ecc97e283bee 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: Other {} | ^^^^^^^^ 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 86ae49b32fcf..1d5489845efe 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 | as V>::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 81d67255a0bd..1ae055851746 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: 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 5f13c781341c..075f3c33808e 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 2fb94d348966..198a185dd484 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, | ^^^^^^^^^^^^ 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 859487f50ac1..e85b46769314 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::, &'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 7f574769b7f6..366b519aeb57 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::(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 294684d26bdf..5b1ebf2d1a99 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: as Projector>::Foo = t; LL | let any = generic::, &'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 fcaa583e2bd4..196e74d39600 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; | ^^^ ...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 ed2f8624357b..4fd7d2f0ec72 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::, _>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 9b8e793dfd2f..9a2bb7d1c985 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 e24ed695dc55..d63362a7a601 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 b128b6518ce4..b8ec1fa5654a 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 dcc98e855d1b..0e3081ddfdfe 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 e9959567e06a..830a07c4f5f7 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 393350ea3f12..2b5277f93328 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 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 393350ea3f12..2b5277f93328 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 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 632f0f81624c..aa7b51dc5df4 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 632f0f81624c..aa7b51dc5df4 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 fe5e1d6d2854..2f5408beb966 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>(a: &T, b: f64) -> f64 where &T: Mul { | ++++++++++++++++++++++++++++++++ -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 ea7b2048e836..9a04f3e7d621 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 23696c32bef5..5d4626c161ea 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 1c8f43feca43..2513fef909ef 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 0ca565787f6b..f530e5a769ec 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 05a49820a822..0a5ae8a027e4 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; | ^^^^ 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 8f9ce3ef1e99..2ab150fc0f62 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` LL | struct Runtime { | ^^^^^^^ -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 575ace2374ee..44c7c099832b 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 = ::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 b67ac5adbe14..3546cb705554 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 bd0e7ca2c02e..8024ad28d5ae 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, | ^^^^^^^^^^^^^^^^^^^^^^^^ 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 49105de3d691..fd45fa3cf74d 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 e47ae0b65af0..22b001c80017 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 6a4d4b8d5212..691b4ddc8e1c 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 6e12321c2333..2517cc6a02cb 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) 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 a19708e46bb1..62500866c49b 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 ede31a2c7bcf..d6033bc6baa0 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 43cef7027a2c..e077bd7ac2a6 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 | >::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 668228abe093..af005db58809 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 b6dd67538993..4244e34873ad 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` 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 6fd8a03fd8fe..17ee93988786 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 Option { | = 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 c4f00c9f55fe..1a410519a4ed 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 62c732fb1d95..85c05bd05db1 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 e8bab322a383..193d09e35011 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 a1b671b4a321..119b3109c632 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) -> &dyn Super { x } = note: expected reference `&dyn Super` found reference `&dyn Sub` -error: aborting due to 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 a1b671b4a321..119b3109c632 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) -> &dyn Super { x } = note: expected reference `&dyn Super` found reference `&dyn Sub` -error: aborting due to 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 48d331e81b0c..fcc80c6148f7 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 ea44a81e2a7f..c888ccc1ebb0 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 ad80a009ece8..d075102b2e85 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 bcba37cab784..47ffa68b8ff8 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 bcba37cab784..47ffa68b8ff8 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 4b29b55bea13..68dbf5dd4e8e 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 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 04c05df0616d..9a220d24f3d6 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 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 dfb39d6ce159..5aa1a4a3c320 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 04b29ed77340..2e86be730cc1 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 01829021b4a7..25df34197947 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: 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 4cfceefb24cd..fff602b8d2be 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(&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 89360c44e78b..503d0f125218 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 9345c2711978..53eef5d0b13c 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 ` 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 5346a7027163..9ce1d0b76328 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 ``: [ 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 59246fb1b037..c68c1481f4d2 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 37774c59e6cb..2c581664f395 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 bfbef8b25fcf..fd98e355fb91 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 e59301a8ce9e..8823f40e5349 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 420a9f330083..d5ed205d14b4 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 b4591778f8e7..10e057ec104b 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() { | +++++ -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 a55d71d80682..a84d2726fa98 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() { | +++++ -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 b36991e1c01c..62a7a2b86224 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 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 4b3eb6c517d9..6dfd83dd5144 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 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 4b3eb6c517d9..6dfd83dd5144 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 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 c49eb6097bd0..e5d8466c3236 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 c49eb6097bd0..e5d8466c3236 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 4b4d6ad0298e..8b22f89c7efd 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 ecfe4865962f..982af825918e 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 f2b72357f792..a0891dfd01eb 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 307d0dfe50d2..50d060cd4743 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 bfbef8b25fcf..fd98e355fb91 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 553f655a10ac..e3493e184893 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 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 827df05decb8..cf94d72b883d 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 76dc7f340755..57ceac61f16d 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 863ada3c2c44..cb2e7ec29a5b 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 // 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 7b0f1b4d56ec..434c3fcd278e 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 // 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 df19477ef269..e987aa595b96 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 // 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 dd19bcd54e32..6ed1cd6cec45 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 1e9dff3ce89b..d37050fa58af 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 f5480e0b9fb8..ff5c5c3a5dd8 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 26679e713803..554b3a64cc29 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 b3ec3cd8d9d0..e48d48a7271d 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 39cf943f4d8a..185bcb4071be 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 62cc26dd4010..2760e930102b 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 c397385017ff..1679fc2ac18c 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 94e8f9295fdd..46798f5dcfda 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` to implement `FromResidual>` -error: aborting due to 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 a10d7af470c7..629ca2b37fa5 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 41244209214e..a868adf411b0 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 8b9dac6e291e..ce21751f39d2 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, Vec) */); | -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 1fbf180c673f..3c7d6699be2b 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 213ca8f885cf..6d0558d2876f 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 6870b9d7d09f..2e6136eb9599 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 51b1c8a1068a..3c143f342161 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::; | | | 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 f190bfb69839..7ddcc318f88b 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() -> ::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 aa79b1a57c4c..404e376e364e 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 e594dc577b1c..089c3e4fd8ab 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 d7247302dd1e..2ed918eca171 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) {} | ^^^^ 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 d47b1fe3678c..f6f754557991 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) {} | ^^^^ 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 8678e9b33b5e..20e478160c61 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 = 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 962dedde09a5..ad1b9f19d8ef 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 a845cba77163..bca88b5fae10 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 = (impl Debug, 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/type-alias-impl-trait/coherence.stderr b/tests/ui/type-alias-impl-trait/coherence.stderr index 36bbb985ef02..4462b70f782b 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 63a3ce29cc77..893a27faced6 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 f2aee798608a..ef170101b445 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 d5fc46cb1f59..948bd6deacd0 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, 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 60bc24320a30..772f487d96aa 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 a8b4cd7afe8a..9e6169b2af73 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 b138f9d5c45a..e5cee49cf296 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 8fc2e22848c7..0fdcb81f6672 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 = (); | ^^ -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 09dadb0afcef..2a77eb4c4ac3 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 146a57cbb7e0..abf4a0d241b2 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 0c50a84e8943..07ba17ad27b8 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 8205a60ccdd7..7dce067d39c6 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 e767bfdb08b6..5250252a0da4 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::::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 7e76c120a256..b20073fcdfcd 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 = impl 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/type-alias-impl-trait/generic_different_defining_uses.stderr b/tests/ui/type-alias-impl-trait/generic_different_defining_uses.stderr index 47ac3346259e..72271d158a1a 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 3dbfff7453fd..d2d6380b65a3 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 = 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 21a5369d9fff..2338dbd522b7 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 = 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 648efd1cbfe7..00aedfae4637 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 { | ^^^ -error: aborting due to 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 85e8a600ce37..5a6998f41658 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> + Into>; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 39f584dd49ca..e037dede2e0f 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 8cf8fb1d16c4..137a4db81b56 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 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 c312ee7dece8..a13e9eaab3ad 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 1c83105a18af..9840bcef7d14 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() { } | ^^^ 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 a6440f02c27d..2259aa7bb150 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() { } | ^^^ 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 6f11b66634b2..64a203fe4658 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 151564c3b45a..f3f9962f1068 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 cbc5e6073181..5967a9468302 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 81bc64bc32c6..ff11aee40261 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 = 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 66e4783157b7..9bffa94fda16 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 b93ea955c89f..f0cf681d8bb7 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 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 9a0e71b4eed9..3976a43a89c5 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:: | +++++ -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 80b6aaaf919f..11d9cd0af081 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 ef7abe588644..fd7488fa2601 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) {} | ^^^^ 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 50ae6f386411..d820df472f95 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 6ec5d13f812a..169d8e41d20d 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 47bae8bd12b6..41c5206d9e88 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 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 a611b9fe448e..a099b7d8b8a6 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 + '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 4c5fd22556aa..4570ce8e41da 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 acd40f9804ea..ea4c5297ad5e 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 = 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 2109cf8a784d..8605a0981933 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> = 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 0af3a75f8532..fba1802efd20 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 f8b8201e2ebe..a31aabedba54 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::(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 31b6df5d4c31..7efb05f40b07 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` 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 8d11b4888894..314296b5bb31 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; | ^^^^^^^^ 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 fecee27797a5..583156b9f7cb 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 f6692ae32073..6accd45bad65 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 b7af3f06d0d9..aa7bcbf6a02d 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; | +++ -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 30c3ddd8659d..d6ab26e30daf 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 ff6bacd277e1..f5ca56bacccf 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 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 66886db6eb94..c09efbe4e133 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 053546e4b928..68dd6570d00c 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` -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 6a75e1bd2c0f..461da20f37b6 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 Trait for Out { LL | impl 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 b636ada8b75b..91d71339a084 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; | +++++++ -error: aborting due to 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 ead28769f066..bc233a532143 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 = 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 0c45046f5f51..37abb3fe021b 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 = 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 360ecfa61bfa..5d081e6b1eff 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 728244a1844d..4f4ca1041d76 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 af758d8099f8..2390b7253562 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 impl Future {test}>` to `Box<(dyn Fn() -> Pin + '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 9b651008371f..d5c56636f66e 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 Box> = Box::new(hi); found opaque type `impl Sized` = note: required for the cast from `Box impl Sized {hi}>` to `Box Box>` -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 6bcae6e53164..03cc943d5099 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 { 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 b2de2effea66..b0e6d13b0e1f 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 = 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 278117009124..b050b08a8e2e 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 81e603e2355d..552cf3fda300 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 66a6b0bbf743..b5f38074632e 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: &'static A, b: B) -> (X, X) 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 0f752212ac9c..c7a4b2115bf2 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 bbe709dccab4..c3128ea6f5e9 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 49c59f7eb37a..cf6e42bc722f 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 62db019ed6a9..172ecded7a2f 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 dccf84362f0f..c549ca5b2ce1 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> <() 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 b1d947a9ccf4..ce5d30370534 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 732af5c0b561..a19d4c4eb716 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 fa6ecf68d28f..3e67a162f0f0 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 f3e8ae9c7dba..fabc80c0a4f2 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 ed5590f9d717..2ba4c90a1c43 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 = 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 a621bb519cdf..d4528fb76fed 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>::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 b267e6a75449..dbd80ffa4f6c 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 = impl Trait; | ++++++++++++++++ -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 b2898a21190a..e8925b9b489f 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 7481557fcbad..eec35548c550 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 e4209643b7a3..05825e686259 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 c2cf70687fd2..ab57812ba9bb 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` 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 4155a114b4f9..15ebcdafca6f 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>` 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 dbc183f54f46..b1ccd5cc402d 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 61287f268066..b0415db0e55c 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 e57c59d61657..5641ff301649 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 8cdce2f8e81c..cff2695304ae 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> 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 a770eeac39b7..3d43fbe0dbcc 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 3f3699ce5324..e2dc887989b2 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; | = 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 6cc5b7a8a0a8..6d9c8eabfad5 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 65139307f8e0..6206f169c5b9 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 82c4ec97335f..f4a121ce440d 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 103636b6cdde..e4de9245951c 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 = impl ProofForConversion; | +++++++ -error: aborting due to 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 12d85a49d01c..34b50fb1f05e 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 e0005489d1e7..47bea7bbe608 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 = 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 2858afcd46f0..dcc4b8021eac 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 = 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 285e4f18ca30..121664bd9569 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() { | +++++++++ -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 58ae8617b9bd..09a42f73490a 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 = 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 c20074dc27ce..18c8bc1a1b36 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; | ^^^^ `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 f3da50df9269..a35e644d3aa8 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 7e15e42e3ccd..26d93dcc2727 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 72c33d16cabe..cd2d9e2bea85 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 6ac63a91ee9a..d1bbe308ed3d 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 { | +++++++++++++++++++ -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 81af024b3fb9..3d2e0250dd21 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::()); | +++++ -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 e0fecc72f309..c9dfa0bf587f 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::).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 209abfe5cba4..dc0bea58a70e 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::(); | ++++++++ -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 d92892eeb84e..31e6e805e6c9 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::(); | +++++ -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 254d36cb9479..6cb42fad614a 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 74d85a75c85c..562ce53052bd 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 -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 a1371432f5ad..2c567a1a0ff6 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::>()); | = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #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 0ec527ff5a95..cd184ceba331 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::(); | = note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #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 7370bc764676..65e11ec52fc0 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 fe99821198e2..6f4b380b4e74 100644 --- a/tests/ui/type/issue-101866.stderr +++ b/tests/ui/type/issue-101866.stderr @@ -13,6 +13,6 @@ LL - TraitA::::func(); LL + >::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 67078bcfe89a..b6056f0fd65a 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 dyn ToString>` to `Box (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 a3619d863e25..395559442d1c 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 2e10125943e7..abf24763abc7 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 = 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 ca828ce37eb7..b01323b4e666 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 e6f173a66587..258eab5b91fc 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 fc094e8cbad7..a9d766e4c3cf 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 87bba3166be6..521d25537f3b 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::(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 e3afa497ac20..2ae5873c8242 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 -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 e823bad2668a..dafbab8278d1 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 7be00341d101..fa90240d34e4 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 1fa253052e64..5f389bee7107 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 447b22a152d7..3a8d9c71968d 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` 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 fae7b79269be..e3e8deb30464 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 d15fd23418bb..c6c1d6893243 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 4a9bf610647a..2a089029b0a5 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 a431fe89c237..229729a9ba68 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 847bc517ea3d..1ef02321e15c 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 238764812364..663799e9f86b 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 c8c01603cb84..703694abe594 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 = s; = note: expected struct `S` found struct `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/type-check/point-at-inference.stderr b/tests/ui/type/type-check/point-at-inference.stderr index 5fc94d4d1b6b..b5b0353eb18a 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 64c7687f7a88..15d47cca3d20 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 9a02bc28752a..5ef522fee2a8 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 67a4745b399d..16d08b267226 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 f0ca8afca4e7..8e3e2388c6cb 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 7529f25bd8e4..1d0e097fdc32 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 c538d67316c6..58783fe1ff00 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 cb0e982877cf..8cc4eb36d82c 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, | ++++ + -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 25b4bff4d9aa..999ba4b5fc53 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 0b76ba8eb7e8..b7c828b74793 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 -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 5b00d387aba5..32290a2f5bfc 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::() | +++ -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 7c9784308391..93c370fd893e 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 b9b3a5fe5ec8..de9bd33eb1c2 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 68984bc1c453..3c67cdd0fbc5 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 864d33e0e93b..be0798ab107c 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 5b4c48171983..41b16a772ca9 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 02e87d701b68..b651d80292d7 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 f7077e52a707..3ea409435779 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 428a0792091e..86eb163b4713 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 42c64b03918c..9a1d5d964fa2 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 1f68abcfb437..1b7daa9c2b9b 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 ddb510ef0477..143139b2c089 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(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 f744e5a41f0c..375c9372ec28 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 8921e3f7694d..289c8d161ae8 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: ` 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 b97e74b7e53f..180b0183a3f2 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 Pin + Send + 'static)>>>` found struct `HashMap<{integer}, fn(_) -> Pin + Send>> {::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 75374fa6121e..b25b6c0c0b78 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 cf2648d08407..c7d853428dd2 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 88ed96e148cc..02c212e2492f 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 3307e76d9575..5941ea188b53 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 6bc0de77a626..063e21f40235 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() -> [ (); { () }] { | ^^ 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 92068df6c057..af50e8da7f0c 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) { 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 3d8f824ec94c..1eead9563286 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 b774ca22dd72..808226015b50 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 5e2ba0ef4fc5..0575751a8962 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 bbd8042d1cd6..dc723952ff10 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 f1e0f4719281..3589796b6aac 100644 --- a/tests/ui/typeck/issue-36708.stderr +++ b/tests/ui/typeck/issue-36708.stderr @@ -9,6 +9,6 @@ LL | fn foo() {} 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 c072e6a08ba0..2e12651699d4 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 26fc21dda06a..16beaea75db7 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 9e48ccefd86b..24dce4697929 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 7ed9cb103798..ec31766324b2 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 a631dbb39fb8..4c1bfc0cbf77 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 6c3302f29c2d..301838880629 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 + '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 fc7c23a22524..1b70c6f9d02a 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 2a747f679a84..953cbd206dc7 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 9376e8bcf80b..a4cb53025e3b 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 4d456ae842f6..1dc798b5e229 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 b1111fcf1484..36ae7d5de1bf 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 f489ae2002a1..ff781a68dc69 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 f0ca49e6d1e3..a34ed08376a2 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 d313a887abd9..800369b51765 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 16afac4bd6bc..e4b5a155e49f 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 de3dc15a54b1..87145d9bbd63 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 56817ee2ca9f..93c52f3c5b37 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 f0bd3e0ddf76..eab494ffbdf2 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 dc30975103cc..96ac481438f7 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 645c04b87a1f..ebae93cee2b3 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 90bba90be346..68473f65dcf5 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 6fa0915dcaf9..bb407fdb8a9c 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 d73e647d21f6..6686d5f977e6 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 c36b4967ee99..554a06cb6afd 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 484089f9e87e..a24f9cb540fc 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, code: impl Into) {} | ^^^^^^^^^^^^^ 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 8586f522291b..43e96e1adc6b 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(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 61549dd701e7..fa18056e802d 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::(); | ^^^^^ 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 02cdc102c15b..fff9f5da16ff 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 a75024aa2481..2d4069f50296 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) {} | ^^^^^^^^^^^ 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 7a0cfb2cf51a..f2f996c7b304 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 d87d3277d563..a1fdd8359a63 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 167edc8942ae..c1489d9bcaa1 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 3a67ef0260b4..d2fb8169ffca 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 08a1d17e244a..b7debd335b0f 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 3c9806ac965f..c854460c34c5 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 234110f31f79..96998ca244d2 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 b990b5f951f2..a79d6b600ebe 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 76a2a5f99f2b..82207a731b96 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 4507a4df621e..c6df6650654a 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 b01e30be54de..3e03c17f3b1c 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 1feaa0508bfa..14642b25c994 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() {} | ^^^^^^^^^^^^^^^^^ 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 8a6ab61100d2..bfe01f3614e0 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 705b029bdeab..b615d9fb45cb 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 ad7f85e01ec0..f27ca1dd5820 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 72ddebab486c..9557c41457dc 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) {} | ^ ----------- -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 a821088a4b30..8d5b57ead03a 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 9c368e83834b..77299621ab91 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 + '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 9d0a609d87f8..064d0d64e078 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 + '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 7be46ac073ea..ea9c74be3623 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 11d70f8a4336..0b68fc97e788 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 c4f164295634..3a7e2068ca63 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 09df4b34bb52..adc336db5016 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 8f1975374a57..59d9392c236e 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 81d968454be7..670ff73e28b2 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 468a14762c0d..cedb1b13b1e5 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() where ::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 2ce32990e55d..771272ad10b2 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() {} | ^^^^ 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 887a1ddbb692..537ae6b2b5f6 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() { | +++++++++++++++++++ -error: aborting due to 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 c4e4aed20673..e4b1c02c2014 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 302231777bdf..fcb5ecc4042b 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 598273af9cfc..7f67650fd4ce 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 529cbff0563b..b67ec561531f 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 c686a0b2f5ae..33a094ce95d3 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 01d3079b246d..7be923d93835 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 75b6c64f2ced..f07c850e5566 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 147a20974732..0815ae1fb5a2 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 cfbe1c6f2cbb..66d393c67c54 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: 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 35ac9ebe2910..207438bc9d8b 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 b824d160d716..d06fa3007dfb 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; = note: see issue #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 9d3c1902cf30..563167f3c0b0 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) where F: FnOnce(Option) {} | ^^^^^^^^^^^^^^^^^ 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 43e9af24a7c2..70407628f1df 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 a3b32d2c1c8c..b5cef0b3a27b 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() where A : Eq { } | ^^^^^ 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 bccbf307ae15..923f1a345136 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>() { } | ^^^^^ 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 2b8fec86c8a1..b7e9e1baa7bb 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 8814617814c9..0465c20dffa2 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 4df404e8198f..ce2c90f97da6 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::::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 e4772478bd91..b8fb0702a08e 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 98fe97c5c181..4adf24162a07 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 ff2a597bed06..5a76ef3e8758 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 = 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 ce4d0fe25f51..795bd0a0d180 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_itisize>(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 e97157b83980..40d341402455 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 846a44ce4d7a..cc81ce9bc360 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) 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 3f539c42d9b3..b18f67a99838 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 e3b19297b9c1..1c465f409474 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 ab6f06518467..7013529a8572 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 8d70a2b17602..2884dbfd29da 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 7d15cd0c882a..cbe42861d5ee 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 830f6bc993df..178cabd424dd 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 e2d867ff266a..4d5e6f479650 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 19ac74fdf583..4af6f412e5b2 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::; | +++++ -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 1df6d8b446d5..72fd0202f4e5 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:: { 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 b0e4d88f6718..a663f34cde1b 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 f2c19405bbb8..da2631638928 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 fd0860028039..e2bd9192d57d 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, | -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 60b0b3ee7ba2..c3bda45e929a 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(items: &[T]) -> Box + '_> { | ++++ -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 6a104e8f94b3..fb036c695b41 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 2b34f0c555a2..ed9d22d25583 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 4b38a26f957f..4d23abf83dae 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 3e197dc9a9d1..54e62f34fbaa 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 08b4268e5d23..36f3e9ef1452 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 95939fd6b7e0..d65c6042e16f 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 95939fd6b7e0..d65c6042e16f 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 8c5bbb631b4c..92b7a9c2af89 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 0268c59fa4af..63d8b99ed18f 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 92caff0dcde9..dae9523975d1 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 92caff0dcde9..dae9523975d1 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 b04a7b7f2f1d..43cc377006e0 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 0dfd22a30acc..5f2f02c99fb7 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 daf75f51b5a1..304e738ed256 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 ae1c4dfed9a2..c9b6903b1bfb 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, | +++++++++++++++++++++++ + -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 21f4ea103ada..3b073ca1fb4e 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 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 2b0241caf98c..f43fb2fe9e51 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 dc87f4de5219..e9dbb275944a 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 ff6fa48db90f..bd63908b49a2 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` requires that `String: Copy` LL | a: std::mem::ManuallyDrop | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 136cd883e26c..86e7c955d2ee 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 136cd883e26c..86e7c955d2ee 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 a80b27e6eb56..03a939769c78 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 6e21584c37c0..8a3677d525d6 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 6e21584c37c0..8a3677d525d6 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 c266d2e9e138..90d38727f227 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>, | ++++ + -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 49124eee5ee5..0beb7c376f3a 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 22301582eefc..ee5d1e37b141 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 c5fe9b8ad0e8..1e0256867c56 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 4a1370ba80a5..361d359a10e4 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 9913747b88ee..9bc5e7dcf226 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 15bcc277e649..6fa3e8ca630a 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 f3fcb4a4e921..b6259484f67d 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 3808f8583b83..a9e40884bfb1 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 8df8eab34a71..24ac2f8e6213 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 28333228a29b..b493d0fa3fe2 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 5e371b70bfa5..1c006049756e 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 f139c0f3cf1e..c6812dbb1963 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 d3cf5d84fdd9..5157dbb514ba 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 00ba0f7a6a3e..8c221314cd7c 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 13438fd31d0a..56b112867cf0 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::::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 633f1edb26ce..e38a9388a786 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 633f1edb26ce..e38a9388a786 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 7384899b978f..9dd68d2a6344 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 f395c30b8155..a1ad98d205eb 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 4d8acac61d9e..1018218b1b06 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 660c4070451a..23bfe3c9c2ee 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 f9ef7834e1e5..ef00edae05d9 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 f9ef7834e1e5..ef00edae05d9 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 9eec0b09e9b1..72bce5de0aed 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 9eec0b09e9b1..72bce5de0aed 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 493483d2c454..4f2f1e42e765 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 493483d2c454..4f2f1e42e765 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 a06c6f479b8d..a2a3ae668a2c 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 a06c6f479b8d..a2a3ae668a2c 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 33d134c7ce59..563b9be26721 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 { 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 33d134c7ce59..563b9be26721 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 { 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 9abc51424aba..f8b55e0668d4 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 9abc51424aba..f8b55e0668d4 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 44f77b99c561..d29e49d73a66 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::(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 3031be720f02..2450f08664c9 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 1a77adf4459d..199dca9237e1 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 fee645e4118d..da3d5f3bd291 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 bbe4a415b5e5..aa5644782a41 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 f563118e8ac0..c3ab80202226 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 1d6fa4cbf407..d33474370755 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 206dbd90a752..75431666186e 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 b08a7109dda5..01e8e49ecfaf 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 e81dd3b2b418..c38da7226f61 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 2db7cc31280a..1cc949cf757b 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` 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/unsafe/unsafe-trait-impl.stderr b/tests/ui/unsafe/unsafe-trait-impl.stderr index 18ba79404b77..db5200e1c203 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 dcb84a80cb03..79133ab39a0c 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 dcb84a80cb03..79133ab39a0c 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 4f13ec7ac08e..6a93464febb1 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 b6002cf895f0..ee8e4f3eee26 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 8cccbd792da5..15f70b18b324 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 8bbe317ec74e..b39eb2e70bba 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); | ^ = 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 8f09b460e004..160e14794d51 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; = 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 13fdc037ac56..e1fa41de2a80 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 fff7ef75b332..9eb0f3dabcca 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 88269f237afb..47b6d72acc7f 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 57d9978225a2..9dfedfd8ada7 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 6087f5c54652..f2828b384b25 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 71bbdf5dec76..cfbcd0aea901 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 6b982a73952b..df0b998fd883 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, | ^^^^^^^^^ 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 6b982a73952b..df0b998fd883 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, | ^^^^^^^^^ 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 aa7f9c78fa84..f5f2f7192aab 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() { | ^^^^^^^^^^ 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 da5c43224034..d1d652d1860f 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> { | ++++ + -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 a43b8d0741f2..632af02b4b6c 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> { | ++++ + -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 b1ad0cb5b88e..0d8b59aa9227 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 671d409937ca..82446151a7e9 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 daef984404a7..aa3f8fae72a1 100644 --- a/tests/ui/unsized/unsized-bare-typaram.stderr +++ b/tests/ui/unsized/unsized-bare-typaram.stderr @@ -17,6 +17,6 @@ LL - fn foo() { bar::() } LL + fn 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/unsized/unsized-enum.stderr b/tests/ui/unsized/unsized-enum.stderr index 9e6408e81436..8c56a83a5122 100644 --- a/tests/ui/unsized/unsized-enum.stderr +++ b/tests/ui/unsized/unsized-enum.stderr @@ -24,6 +24,6 @@ LL - fn foo2() { not_sized::>() } LL + fn foo2() { not_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/unsized/unsized-fn-arg.stderr b/tests/ui/unsized/unsized-fn-arg.stderr index 0f6fadde19a0..c8a6622b8092 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: &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 9e5ad92eb04c..3e16a20d726d 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 S5 { LL + impl S5 { | -error: aborting due to 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 93694f6827f9..89e87c9d5ac2 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 0951dc670fe9..fc526878ef05 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 6c23178c7001..350cb18f9527 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 7b4d2454994d..02a6ed599a92 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 84487a8d0dcd..35ede21717ef 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) { | | | 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 1bdf49801f97..17827becccec 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 59cc22eadb01..ebd6cef58b43 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 4bc0d7e61cb2..f0de7a7466c3 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 dd4036bfff47..a8f65b128fe1 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 62b71fe8e12f..b793229e5fdd 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 62859e261a36..22201361c584 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 2d2c90067aa6..f9ab346f8c36 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 7234c8ec621c..d73754c6baa2 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 b09001a9bcd4..c54f40dafbcb 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 131c476aa55c..9c081a287ed7 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; 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 4df2d8da3d68..e25f0879add0 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 { | ^^^^^^^^^^^^^^^^^^^^ -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 35871c1236fa..158b09b0630c 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> = 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 ab5435d1656d..18e2de9f5024 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 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 55a760425ee5..963f3454e1ba 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 3308cc6d2501..9c72fe239dde 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 bfcc8d4a1d11..f0471a346192 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 50de7c90f135..5000787b8f99 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 bab858c5acb3..bd8458cd85db 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 241a757d4452..cbc3eabd1d1a 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 2b85fa9bed48..34b501f8ec88 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 5227badb77dd..3129f2a8c341 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>(_: &< as TraitB>::TypeB as TraitA>::TypeA) where <>::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 c924cd87997e..3ccfd7f8d792 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 f80cd41a4c2d..1b14045d558d 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 { | ^^^^^ 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 1407e62b1e13..622d72f791e2 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 { | ++++ -error: aborting due to 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 7f3c58d6bba2..6bca8d036d52 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 6a623bec815e..161ee9d7059c 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); | ^^^^^^^ 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 d39fc0c6a459..78b5c6ec20eb 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: 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 c12d62521f77..2f2c1c2d2665 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 { | +++++++++++++++++++ -error: aborting due to 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 ac3301a965ac..a5feaadfc758 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 { | +++++++++++++++++++ -error: aborting due to 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 e6fb81247ad6..f17d33474f40 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 bdf8bba5ee02..09e255bead02 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 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 1ca368729fe6..86fe6df32bf2 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 83a4a592ad31..8f22edd17a10 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(_: &MustBeCopy) | +++++++++++++++++++ -error: aborting due to 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 7eeb97472832..85cf78c59879 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() -> MustBeCopy | +++++++++++++++++++ -error: aborting due to 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 be5e9d4182be..17594c813daa 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 { | +++++++++++++++++++ -error: aborting due to 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 8fcfcb0b21af..fac535a11265 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 { | +++++++++++++++++++ -error: aborting due to 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 160a738409bf..4c556d3d77de 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: 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 b10856571a61..0af4ab022e1e 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 4b9b189164c6..9e837b10e284 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 { | +++++++++ -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 f556b678e0e3..b96f56a12a54 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 { | +++++++++++++++++++ -error: aborting due to 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 e723d1ba76bc..4cfbec12b6e4 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 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/wf/wf-inherent-impl-where-clause.stderr b/tests/ui/wf/wf-inherent-impl-where-clause.stderr index 39e0d348ea5e..bdc1ee3e0e21 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 Foo where T: ExtraCopy, 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 64969fbe3203..cc5351346b35 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 52f46562c371..8e3088c6f4a0 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 6248e3e4e43b..4ac7f4634e46 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: 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 78a8da8602a4..241ced3c2dbd 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 { | +++++++++++++++++++ -error: aborting due to 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 8297700171fd..4ea895a9b039 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 { | +++++++++++++++++++ -error: aborting due to 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 ca7aeb55b250..d6647b2cb96e 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 >::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 a73c3a2aed60..1dc8e2d87a21 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 ::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 bace3e3ef008..5845d05b38e6 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: 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 8c3d0568fdf1..a885f8988627 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) 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 6422e862d287..f749ac7b1b3e 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 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 f260d5750c56..e44a96fa5894 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(&self) where A: Bar, 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 3bd1f48928d7..8b35f36fa68a 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) 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 9bd3cc7711b8..3d70f04def2e 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 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 d064f7fc56e5..0ad3b58e7c76 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: 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 cd49243a4bf0..3c05065e57f9 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: ExtraCopy { | +++++++++++++++++++ -error: aborting due to 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 29b36f44a4d1..4c15497d5308 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 782e7dc5e005..3318c70f1bb3 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 cfddc3e10b64..4cf553da4c5f 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 ea51f5084f87..7f92ac102f01 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 43fbc0a9061c..2612cefef28c 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 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/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 f2db8fcc4a3f..090df26a39e1 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 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 E0277`. diff --git a/tests/ui/where-clauses/where-clause-method-substituion.stderr b/tests/ui/where-clauses/where-clause-method-substituion.stderr index 2f3b615a13bd..1a1d9c13ab89 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(&self) where A: Foo; | ^^^^^^ 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 6cf717295141..840df342ef9a 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 4d239bf43079..205b82d49bfe 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 f65db78fc899..f47921077219 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 d06afc1e4237..8936e45c19cb 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 88f715d56660..b937956108f0 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 431d37c007c6..27d68ffdb24e 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 0cb843cf0f14..703f35c969c3 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 286267c3834a..06e1684dffed 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 = 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/74] Bless rustdoc-ui tests Co-authored-by: Adrian --- 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 580f70c97429..d7c4e8c380c5 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 5d9c16c07652..e1cb3323856d 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::() != 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 ea05920dea79..5345f77fd392 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() -> Array { | ^ -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 1a00d10d3fc6..c1cc4898ac58 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 cbca40e1364f..cd3ad4ab393a 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 5ba09a2eae1c..a9da75c0171c 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 8a3329aa3ed9..1e9ebd88c2e3 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 61468b6c7457..e288f8dfce65 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 bacbb47b5f9f..11355c232fe1 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 840c9c5084c2..7b0cf9a432d4 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 b65b622c1ed4..c6a5785a24fe 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 5df6132987c9..5177057c7284 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 f50dbd1844e7..38b8dd652d3e 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 72915e46becd..02f4d8d754f9 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 cee5b63cf509..f0ad40eb6ca8 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 `` 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 fab801b3beae..1ed455422511 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 2641c66f25e7..0574dc8b2820 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 edb5dfd4d55e..69e2eebcdd86 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), | ++++ + -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 aff7402bc91c..c169ca670a63 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), | ++++ + -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 349a569414cc..bd5de384cdee 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), | ++++ + -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 0864159c8e22..0b982cd9fd3d 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 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 9e2c3ff16420..cc914de6d1eb 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), | ++++ + -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 5e7ffeeb8a21..a38df98433d0 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 04594ad41425..7ce677e863bc 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 a69b1c52ac55..5dc610179604 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 3e08354a61de..ace20a5fe972 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 f45a3ca615bb..cc0ada873af5 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 c43cda3eb7e9..b952517022b7 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 a8dc91204c08..9d16219be2f7 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 7430044ac3f1..f7dabed29796 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 fe2d8cafa302..baf23e94f45f 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 1d302ff42e86..542352754761 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 efed0e2ce0ff..a2641c251707 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 81ef799617cc..b037b7933ca7 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 c98a2fd7ce69..2a30359238ae 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 e8ee40ad4e87..765f26c48455 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 14f560618521..8315c73a639f 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 815324563cb6..f9f135a922b8 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 8658e3825782..82faaaab47f3 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 1a8863fb18f5..9c6ae0f76c6e 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 = 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 a337293f7a05..4a769f94cf26 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 = 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 9aeb3389e2d3..d056dde00ea0 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 3a573726c972..996eb41c492b 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 e163bb4db9ee..d992b219b3bc 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 2dd9beb17da9..2c63c345e46a 100644 --- a/tests/rustdoc-ui/issues/issue-105737.stderr +++ b/tests/rustdoc-ui/issues/issue-105737.stderr @@ -7,6 +7,6 @@ LL | impl Vec {} = 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 0a4ff69bafb3..fa79fe2e71c1 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 1c973dab61d8..4d063b461883 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 1b7f8bb552c0..de376ad809e8 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 9c9c9106f8ac..0b96b6593097 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 d16ec6a853a5..f351f52d1e15 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 d187a2e664a2..e7b433268e8d 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(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 561513a432bb..cb030a3113fb 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 748113be3a26..6313dde32c57 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 c4809a311fc8..62d81534a987 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 = impl Trait; | ++++++++++++++++ -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 0867b08183e2..24597f09db67 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 58612327ff93..5d93b4132fce 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 b8a08e943127..f188240062db 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 fb3a5e415dfe..3a748335ea8e 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 7e88ce954aca..857bbda2ef47 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> = >::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 34b20a0b32ce..01034018e22d 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 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 5b048097c496..77bdf201924f 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 83f4e87c6ede..58d61c0213ec 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 39418d359288..131adfd588c2 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 d127fb858d17..51fb87214fd7 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/74] Bless run-make tests Co-authored-by: Adrian --- 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 a9d856503e62..0553b22a45ef 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 7b53bd16e7a5..a50148f9ea80 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 ee1e52937b98..27ad5d529216 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 b8a683cd9ebe..4f74cb8409a6 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 b13035308441..9bbcea010511 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 d18e15a26288..d129db9bc676 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 9936962b4ee3..c13a270b067f 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 81b1e7367c75..6e51cb812ceb 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 9936962b4ee3..c13a270b067f 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 81ff83938378..bdbaa3817093 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/74] Bless clippy tests Co-authored-by: Adrian --- 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 f7d53763a438..c308b7aa0239 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 fb0a14081524..1bcde2f30ed6 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 a21952c0e7ad..08fdb2d2dc32 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 6f817a3fdde4..4510275c9a9a 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 d9f25a3eee50..a5fece575f84 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 31bb5ee3514a..e83027e4e28c 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 92b0350581d3..877ca726fee0 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 7c56dfdb948e..3f2086b5ecb6 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 0af8c0add6c6..3c3839633880 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 a4b1e9c335ca..3d37e4daa960 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 4d9bc9d48e45..ca96c47b92bb 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 717a4bbfbfe1..ceec4ea67553 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 305e00af27e5..e0e77bf23f66 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 80c4f5ed4b0c..bb1244ada9f4 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 f127c2408f90..a764840665a3 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 7a02fcdbdd2f..23c6215f9498 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 67ee57ab672d..5adf666278fc 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 6678a2b47214..20026d358aef 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 5c2c86c37318..67647cc5e95f 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 d319e65d06ce..20ffacd092ad 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 5b1f8dbd3eab..5bf2bcd3bc61 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 = 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 b0936319d1b9..cc603fc0cc04 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 ce03d7d75a26..0542e139b340 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 9237c9c9d29d..31e0e33a39b2 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 2859a29f1b2a..54990c35228f 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 923cded5eef1..5d289db8534b 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 8b9d159b59c3..81d9bee737e2 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 8ca637f72225..df824400da82 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 2ae2984975f4..444fbd12814d 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 df9aa37ac10f..9a747a19f795 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 7377921b42ab..5fcc63131bf4 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 13ec3a229ce9..f11fda6a0c6e 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 2a21f5ca236f..296af6436934 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 ce1f2f8296e5..22774d2f9f6d 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 9cd25f6fda98..b9af72371e6a 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 48c3385b6c8a..30535db50cc9 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 4d436e3aa04f..ece3e1c39403 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 fb80b5b147f5..b3dcc00f3d9e 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 ae9610c9acd4..188a5985024e 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 4d3d617b6937..863608fca8bd 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 = 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 59469ec5891c..5358734fed04 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 e75e7dc91367..ee69f3379b6a 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 74d99a348472..1f930e1f6d2c 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 75a26ee318c3..d0067a2239e9 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::>().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 6ace7dae8bdc..7a34e6cceeea 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 db0cb25e34a0..bc13319bef02 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 671933157c80..cba6df194ecc 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 47947f89baf5..3126de93d224 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::::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 e5f14f2215d7..3315a8d907ae 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 7acace78a7b2..22f2c7e46fdc 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 9c57f334581c..397e978af0bd 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 c8bd01fb1c64..94ebb20918ed 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 49c9bdc300ee..00b65f00d787 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 9307409ba585..f97b4536e129 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: = 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 712bd14c685f..1741c7c6a0a2 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 37484f5ebd70..2ebb9d5cd1a1 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 6d45393996d0..b318f8d3f7af 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 3e624618237c..1a21d4e92f24 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 01033246dd90..7ef8d08d5d69 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 f3ffd6a10c71..3bc406206e4b 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 bfd0de4e13ac..6a00331ec69f 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 2db1bc092895..e1883f349b02 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 a6241c78610a..a4fa1688d577 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 f47f6c89622d..53ee0c4e8c89 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 92d81c7269a5..c9bd887643e9 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 cc0e951d9b42..63e9a0af8b6b 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 94d8f1e32ee1..bbe0762c8d12 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 cd324f182205..19abbc6062a6 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 1841553917ff..07760d8837a3 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 afb7c6b4dbda..f49b7a0977fe 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 1d6ddad79ff2..497acc0a65ea 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 11b19428b4fd..429861e993e8 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 80df86ad64ec..8bd4fe3987c5 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 d7c2c88a2047..51debc9b72f8 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 d04b49e52a55..860c545c7b82 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 4e99876365cf..30aa90d29bf8 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 67bc82ebff91..17b07cc32f4e 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 5bba0e635bba..5871d21e4915 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 7361a4a2cbbe..d2922af99bf7 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 6a845c84a2a9..eb6742ff2338 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 842ad3a8565c..c6435e94e967 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 1bfe56d912b7..f290c20e5e98 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 581a985e0b57..771e10cbe105 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 c684bc8e7072..3aa9781c2f1d 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 0b7be4616511..d84d06088ba3 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 9b20016be799..819602882766 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 183e2dbc8c16..e91359a3cc18 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 2ed9208e6230..b1fc1a7a9585 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 e6f7138e948d..66552109c48e 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 73f249ae6c2f..24a22e232485 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 d3c22441d003..bf43a18e7115 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 580970a41aa9..707f1c25327a 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 3e9e2941a7a7..60aeb0493870 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 babb634fdcd1..c0d6a74a51de 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 `::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 001fcddd9068..036d38c22f48 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 ca9f5e1e374c..abf5adce4446 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 163d6b1dd7b6..2210e706d930 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 1453d020c412..f96ce0de7793 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 58a7de84d8f0..bd34463084a4 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 d912b5027551..122374ea804d 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 781572736645..f6f5db9a1800 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 a3f440de80a5..b4e256ddb9eb 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 9f174307b829..78ef17b5ba79 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 636d88fcd69c..662188bbabc5 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 9396ea4c064e..12de3b460882 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 42eb342c10aa..4858cb82e7eb 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 f299b860d478..8083ff965157 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 e5d64e271644..079ba42bd2bc 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 dfcef52a9f5f..b13db83bd5c7 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 cf5688a97824..4738bef3ae9e 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 27a84431507b..f1f8e176bc57 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 112d6ce1f2c4..ec0cdea83d65 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 39418d359288..131adfd588c2 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 b253cf33867f..f7473e1c5c52 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 221efeb50cd9..736a68ab1c7e 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 618c5980d64e..edad35d1591b 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 715c9923b2e5..c16ba4e52627 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/74] Bless Miri tests Co-authored-by: Adrian --- 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 e9bc32204719..c031cb0146ad 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 c5093c0e6011..078b7d2e0d84 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 c2de4afd68fa..383b93024bbd 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 85ae930d439b..70a565ee7c71 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 763e0d3665d8..7238dfb40b72 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 a3253e2ef933..e501a086cca4 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 09e14d46a967..b2edabd7cc98 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 db5d7bfd5dae..605d6cdf0a41 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 8db4a83f9ceb..9ec749acddd9 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 fccd3fbbc9da..2339bab3e9f8 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 02f1eee97fc0..7547ec417194 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 ed826147e3bd..1d6626dda704 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 35ff1926b065..7a2757557ef1 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 bcece7ad4e55..355e16d5c349 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 5a8e7352c768..0988eefe2223 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 d4a38e1ca961..e2ebe234b0bb 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 54b58f22c6c7..b76722f5f8f1 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 8b2882fc243a..5c6ba4fd9797 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 e21b9b060083..4ab37ab569fe 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 7c1c3fe20c4e..3e1ee7b86e31 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 cc11ba89f8fe..0cc7ac19febc 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 54e0cd5275d5..cec67b6ef840 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 35d26972839f..21b4baa50092 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 cb47769c063f..f17473677f63 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 9a084c504374..14eb9d32053c 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 ecfedf753703..899c217efbff 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 f39d909adbd6..ef75b03162d7 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 4a138e6f8a25..3675ce49f30e 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 599655a8692b..272bee38b5a1 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 8aea3f5c6932..4d41141b545f 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 a8ab948116e1..ed5e27b607a5 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 9620fdbd18b2..05b35ee3b30a 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 b7877d3aa397..16de503bebf6 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 754137b85b9a..d717b4ec56b6 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 aa81b06fc80a..a1de36db9667 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 82949047d2aa..a8425e6f81d0 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 be73e7f1e2ad..bb90545c5034 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 bc2713a5ffbf..7210c6a742ae 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 5004f84358da..5032e98f1161 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 075c8f0ef529..21383825f81e 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 7dfa27b43d07..d1b7d5ca1ada 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 1c25ac2c048f..98b09472904b 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 333fb1afb91b..6271d5cb2ff7 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 caab19a782f9..3d09c6dbce74 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 93bede54fcf1..faaf3f5e9a0d 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 30f5f447c717..3dc99a1fd195 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 5bf402c775ae..dea2529b8658 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 ac2a984ed514..59179478c302 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 ec2bba611728..fabe3bbf1216 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 095eeeb79de7..40ed093198d3 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 5fe93c841b22..e9b935d2c83b 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 48d63e590517..76abd96e24af 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 62ffb8142a3f..de76e925c11c 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 fe6a22fadc9e..bd2a6c628f9e 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 24cabb395649..5347e7a95ac4 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 d4e907bd0670..fb3b035b1161 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 52cc579c1e61..9b8a89262016 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 7c14d372f0c7..2adec68c0dd8 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 b22db3eb121e..6903a52f304c 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 655f1b577776..db36d696e1d9 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 678211a700db..fe1f7060f1ef 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 3271a04eae74..4ee154eeb991 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 90134ce367a1..c5bdfcb8fe48 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 f2694b51ca40..4b15e9316549 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 a457bd9a6acc..b04139f3bd9c 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 595381c16ad9..7b8082292a1d 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 b53ae9bd5504..383eb086d1ef 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 106e5c19bf27..5dbcd3932185 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 76f4e81f71ba..bed0b880c3a3 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 97f82db6fe73..68ed09409bf9 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 59377aeb971a..6e87d3ce06b5 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 1ecd6620806e..824a2d36fc48 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 fa3d7ca36762..d2bf4c6a59c4 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 9519c83f71c7..4e5a8bbe0e0b 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 daa4339225de..71d962a5523f 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 4fd92df75d65..7fc795db097d 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 c1e491814658..3a9faeb80eed 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 bb72159be65d..5dd51b5f2577 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 c71780b7e03e..16f8a3cbd02a 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 05cc69553a00..3698937d6fcc 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 3d3d2a24c285..159b6cc9a8ec 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 64e08f545e33..37d5147b5d0e 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 8f677bd547ce..5d093aeae88f 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 66f7f1788e4d..4ba80e13318a 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 1648ca9e58bb..f6eeef33e9ee 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 ef807d7362e4..5a8fbe4ce5bc 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 a5580160c391..be01c5cc840f 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 a5580160c391..be01c5cc840f 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 23d7fdcd03bc..e96e641bb0d3 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 23d7fdcd03bc..e96e641bb0d3 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 7eb973ae7f2a..e78807ec1c8d 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 9a3618ed85e7..5de9c9c14786 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 3e7fe11b5202..264503f2f2fc 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 9cb500679fa8..892b1299bbce 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 258189f88783..35d418f574c9 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 5d126bdaebfc..ca5ac5ac88b6 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 fcabb751db94..c26c7f397b09 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 456af0f1eac7..3900f5b233eb 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 6cbc6a86c091..ae54da70fe2d 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 d21ec9eddc2f..dd1344a3ce34 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 ad366bdabcee..9717dd16b5b1 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 21800d6f4e44..4f79c427b915 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 5243858a91a7..57c4a756cf72 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 677e6eeb4838..8060ea9c4a64 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 26d9f38f239c..dfc99ff7cd23 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 242ae0de730f..6a92fec38ff1 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 5f0fbf127597..e4ebe22b60e2 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 87b9b1361b7b..d391c334faf5 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 0de2f66fe0b2..63eb90b6bc80 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 8036c974eec1..f05533a6bb4c 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 d3a73a00fa60..858afa6fb3c6 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 4c016ea621c7..9358520d8ed3 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 7a9f061228a5..ab67bb516ffe 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 b9ef6dea6ef4..d60df19f9451 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 6a98c9121ef7..22a55f0d37cd 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 c3fd124e6cb3..b252c691c8d6 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 a69116f2afae..52ac2184d494 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 9aeaa7ff0758..c2025332b9f1 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 0f09359007db..e05ffb3d35e1 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 0269f3ab6409..40f2d89850ea 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 8c68261aaf7a..697cee52d137 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 d68b4b8dfc67..655e682636ea 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 8b99c1493b53..1b43c594da43 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 fc5982e7f94f..f3e1796f3c9a 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 ().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 1c105991015d..4195c68d500d 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 38d691f4c011..37dbea37ce2d 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 = 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 9669614d47ff..97b3f3ebe7b5 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 = 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 28a9207cff3e..d5c53e4ad647 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 9b47655a047f..27e5a865069a 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 802995aea50a..b7492a09dd09 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 9d21a3e0a454..fb0f77d2e6f4 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 13a19109e886..7e6edc02bc2c 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::::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 f55f839d0b8c..04186f7ff7be 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 a20c220b6c2d..7e76205da9cb 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 a91d4cee054c..69d11a0a83c7 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 8831d9cfc1cd..4f734ae5465a 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 5aed907b1664..8745048df473 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 65114296f52c..7ee501431248 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 7ac3a9cc929e..deb6029577ff 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 49256dff51fe..f8ede3ac4c84 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 ef6b0c3616b1..55b0b4472132 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 792faf8f5d11..8925de139b4b 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 805d7c196423..b9aa4bb041b4 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 22ef35959f27..0af2911223fc 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 64f654402d7c..6ab77de8afea 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 52c9abd5fe0c..c1471ae55838 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 1d8bf2d0d26c..e51119ddb2f5 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 17bcf24a5057..0b71a41098a7 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 8988655208a4..acbc2306726e 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 55c9011f1b48..761942cbad31 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 e1009472fee0..d2ba738f0b9d 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 22017ae633d9..8ac0446fccd4 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 c3fdcdf9308f..0066a11188bb 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 1e45878bfddc..35f63af2dc59 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 0c574299b69d..6cd232ac3d4b 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 9aff6c6c3a70..61121bb83472 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 f0522404fde0..d674b30c7703 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 b400b2b9a175..eeaada1b0f31 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 e6804f6520ce..2cef51ec94ba 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 bc793e9afb09..ca32984be2f4 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 ea62dbf96b99..038e9079c54e 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 03272105c414..365186bcc4b4 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 21870ef3733e..8bac908b864b 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 dd7420906d32..c9bda00493e0 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 cacf866393d4..ab036247a314 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::::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 36e83b8f3bcf..47b06fa8aaa0 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 fa0d55e5f678..c3de4dadb0a3 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 e4ee8f1acba2..23f775f25888 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 a56eba09df98..c935a548f806 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 2a0759f8a3ba..feba0c5991cf 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 766662ca14ba..b26b5a372159 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 ce93f9398f2c..cb46aa97a8de 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 ccf9732ed079..1756123c84eb 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 e7baf6e23db7..76f7ee189e3d 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 5d9a3af0c8aa..2cd9966bbf59 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 f8140d0236af..723ca75daef8 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 c37e788e6b44..401e8c6d5a8a 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 7557d3710d18..3529ddd3c53c 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 406ccb070bab..2f24425ed1d6 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 d90a7e31d6ee..d475801f41cd 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 9e2751a216bc..ad952804ecc9 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 e9a38b5ae421..3b1df8a9d420 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 50afc1097974..f948d08bdbe2 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 ae5c6cb72b3c..2feba7d8e348 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 17d56793ac5c..0537508babd9 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::(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 ae5c6cb72b3c..2feba7d8e348 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 507b459b718f..c5ca12745746 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 4c477416416f..2be02100a35f 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 4c477416416f..2be02100a35f 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 25e13d747542..f89cee0b8633 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 09e4157b31f4..2f561ed88e3f 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 0d0055bb85c8..d51156b3c336 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 1aa13ce43895..69b710b3d3b1 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 abfd7a9a6c4d..96b483059b0e 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 dd951066c324..48db898a250f 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 cf13be6da012..85dcd29ba551 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 e16c4c0ebb67..ea1867b1a715 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 5d76d9eab67f..12a99fbf2931 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 e8165a73ff4f..926303bb4894 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 ecd9a111840a..7f035eb5e857 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 ab3ff5fcdc12..2544421c7e8c 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 bddc6e7e89bd..4d3cf6e9d3bc 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 d1ccaf89974c..595235088f6f 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 3875c2617bb5..a8b1cf40c043 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 6d1bdfee0073..60dd3814bf57 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 07d76c90e5e5..198896b0dd76 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 7ac2bc2739fe..daf216a142c9 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 558d83bcfd24..2e50d054e771 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 dc12073952f8..facfe9d31f2d 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 e082eb9e3e3d..50f4474cc0e1 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 ad43c2c9d3fe..f95a62535d89 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 81fc9716a415..7274f62b4d7c 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 954bb8721e7a..b5cee95d66de 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::(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 10c53ca2beae..4370e6d6a295 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 f8c519c1b54b..e66ab681860c 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 c1909570d99f..7fa6f7b5bfcf 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 6e3215d9f1c9..d73c03475d69 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 23a4adbd0ed6..b7c92cf4a57a 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:: note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for 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 13a76aae7304..e9ea262caf74 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 a275979e6be1..d190f3de6b88 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 5ae14472a8a6..9889daaa8513 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 ae013fb3d979..0f75657e170a 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 8c2910de3eef..9f66e63ca5cf 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 2c7bbc00e1b1..ca6125ab899f 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 6a264b8b4476..306e9bdc2382 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 1a73822c300f..cbcb093a4e6c 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 27201d9c7cf6..1b903bc97aed 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 c82d6b30224f..560771bc24fc 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::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 4ca41b676e9c..ae78af3dcbdc 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::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 88b8948b0c29..2db3efeaac17 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::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 ca798dd391aa..769c35255bbb 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::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 4ff6eb809854..55df31dddd88 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::(-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 fd17709d164b..7a87de7b3b38 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::(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 fdc1f65dc148..6be9b4924b03 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::((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 9e743a321444..5a467f39d923 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::(-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 ee01143dc8df..5cbf1912139b 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::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 f37b8ae55064..4a4d71f53ed8 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::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 05dcd5ebcf69..1f970b3985c4 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::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 0a914abb2ce7..85e9aa87a9bc 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::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 ddf3249d059a..a8f495f70482 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::(-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 42da33321f37..3da8bdf92382 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::(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 af4c4ceb3f73..57383892c3d0 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::(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 6e384a6fbc7c..7558fafd9736 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::(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 77f05ff91e3b..d01c19b7391a 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::(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 cb5eba490b44..0af13b8bbf32 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::(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 d899d2f808a5..a99bbe15825f 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::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 443b2759c260..cef4acee6880 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::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 f8d88c44aa80..0823e84aaf94 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::(-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 d94e57b1e67c..3260faab780e 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::(-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 59b74f5f51f3..4f64fabc3318 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::(-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 e1102a6d216a..cc8cca70ddb9 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 6a11ebae108f..97fa1f19af10 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 99f28b3e4f81..236b51e82e59 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 9c1c387d5499..a8984c7fa167 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 0b9cda62b33c..32a4461d6bf0 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 803aaaa55c21..0b4a9faf1b24 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 f76881011d07..e03abfb1a2fc 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 6e0744b7d5c3..03ae9bd141c4 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 6fb94cf5f812..122529c30490 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 7cc4bc184a1b..304d362bbb9f 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 2236ad9839c5..83f81fa726ea 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 1fc39188e5a9..9b9fe4da1399 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 ddab24d0c163..44d3749d6826 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 27d4dd9e3e73..85058b008eed 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 7b2387944af0..d4d1830e9638 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 f3bd275b027e..d111644eec82 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 1e5ac5277e6d..b6c43d34b9de 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 96248e7e599c..d29d22d8aef0 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 1720a24aa134..8b517b6e9725 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 = 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 e72cce998d0e..1f978e13bb9b 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 277ceb54ec71..e0c054748310 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 c8445bb3cdc7..3a4ec008b449 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 8eec30c5a52f..07636b8c0bbd 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 f5e96198ee4c..922de4226fa8 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 5a5c7070ae0b..05456eaf1950 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 9267e0c49473..9dc4bcaee2f9 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 9a5a585e1cce..533beaa65ff7 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 46b9f6182172..4c6bae6f0bf6 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 264e9baf053d..f30cf4479e6b 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 ab27c9fe9116..a572f34b92cd 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 378ff9734c16..22e0b1a0d9e3 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 01e569767bac..72187e20e23c 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 38c1647b4f49..ec28384f6336 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 c63cfe065530..2196673c39ae 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 b2969ca3b592..def180935cc3 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::(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 f88afde879ac..326c180fadba 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::() }; note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for 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 a522f6cd4fff..fd1ea5087b2e 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 d49d753d9e18..81d6cdad1572 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 01d931de919a..5a446bb2a56f 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 eccdbff60457..a450b9393846 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::::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 f1cb50ab9be7..7ac65c152e95 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 b8e13b61ceb6..3befe31dc5a0 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 | ::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 12bb944b0767..9c885c37f3a8 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 f44e6ce07977..22e8c558061a 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 ec5f5f5bed36..b68991602ea3 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 6425a5d7a0ad..c1eca7866ad1 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 33dab81d5b08..751894f19859 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 9d3a8df525a4..1720cc893ab4 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 a51ca7fe7e76..6916c9359950 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) note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for 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 413172b25464..4ca306373a1e 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 88bdfb4e387c..1c4fc88989b2 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 42a000dfcc6c..54e104e35137 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 4e5a2dfba342..2d96ae4b7de4 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 c2d007e5729d..e4af01feb8d7 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 5de7b3cf9298..75ca0901bc82 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 47ec710052a2..8b48f7529676 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 6bd7157031af..690f5bbec13d 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 1d828d2e0f5a..e937fa02b0de 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 5e43444572e3..0513ae7e765f 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 12c4b857134c..314e0c307925 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 17e92fec6fd3..778061490f04 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 b1a384bbb521..367e2ee1f0bc 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 363e69ba41db..4739c7f2ac6b 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 8fafc7e82c9b..50bff22f7667 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 319517d062b8..6b1c2941c075 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 9ebabfb129cc..92ccec502749 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 50ceae7cfda9..8b8033b0d1d9 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 3607635c8fbe..8ae140ee004c 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 998ccc8bb49c..a110ed4ebb21 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::(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 eb522b2bc0cf..83d85f8adffa 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 df4adb5ead7c..03f93510d09b 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 09d0f7a6df95..3f911c172d4e 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 200f5f56213d..159a02f2c035 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 5d51790f8a5c..2523e5063e1b 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 f23f834000aa..04dbd657d200 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 fe123c2352f0..36446ae283bf 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 a3003c9093f7..ff60ab09172f 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 b4a02c0e363e..6d4c370050f4 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 a1b9662961d0..e1b180008667 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 d951f81810ef..b40d02ac3457 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 325565fa1e78..966279723c49 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 00ea6b27d4c9..2cc714f935a1 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 bd79b401f667..aa26a003f22f 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 3d0cef241c3e..627c790f843e 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 7f2917e79505..6b8465804a58 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 cb5e7bffde48..201bdcdeb973 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 236c8fb0187d..2a841aa0a8d3 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 45c2197050a1..42f042bfad2f 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 7fff60f25fbb..7a44c8384a06 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 7a159c9d3fef..2dfb660c53c6 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 e3e79f6f0f05..ce3b920c1dcb 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 3a8687ad9aa1..2c81fda1411e 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 dcf37b269015..98bfd56cd3ce 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 1793798d15f6..e3b18e7d4f81 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 17b28dee3c7c..415a85bd68c5 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 1a9d551431ca..248ae62d5ebe 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 b43079c3b7f3..fd5ed383f1a6 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 fbd5d8b956d9..33fcd11ff7a5 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 19e4cbdb9385..a948c5df1661 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 3e11e86eb81b..65b4fc5f3fa0 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 4053325821e7..08d9f33a1699 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 fceda8db4cef..4ee5ec385395 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 1bb3afe483eb..70e9038bab3f 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 ba8977c56745..f8bc1667ddb1 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 97ebe72bf29d..a69fc6ff8bab 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 95fa4c51d12f..22a0b42cfd8b 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 7aca065ca0d7..9d707c3f85d5 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 96cec327b9df..0a017e182644 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 e20b5b89a2fc..1fddcaf3dad0 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 9f7e7a058dfc..0d07d154ba5b 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 ce77976f88bc..905776155eb8 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 1496c353e52a..129b9ffb26ec 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 2bf91b676c4c..78008e92642c 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 d357ab9639b4..b9ae34df0775 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 d346e6fa8959..7522115c5166 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 10f97180b754..b5106c9d9404 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 0e37c4ffb394..ccea83db8574 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 ca99a8262b8b..f605fa9d3b96 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 05be0d3f1e98..f341222a664c 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 ac962311d426..7d8132b85c89 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 4deafa890005..50c02b3455e4 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 7a40d1078b3b..7578b89708a8 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 950abc4cbcf9..5568051905c9 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 5e7213ee6088..877cf1d6e473 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 4c160cd32068..77bbace4696b 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 1986059c50a8..a04609805cb8 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 dc634df831f1..be66bad6fc35 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 ae8a421ca406..a49933b7d057 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 e9daa78543c9..be0e846b6336 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 bcfaf80229a9..533651f2efd7 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 642bf0a71343..30306054fbb3 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 fcbc2e127863..58d22c5641fb 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 1b05be9c54db..87286f1a1a62 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 2f77b27729e7..be85e1a1cee4 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 b58dcd7572b1..a03869f33bb9 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 0f1e7735a0e3..7df6cd9d9238 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 8b3bf8414db0..5644862d23e7 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 addba9d809ef..a9d5b0a68c15 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 056ac6db5503..32cf1c18cde7 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 fc92770ed165..ba6c30cf9354 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 4b4b8f24a68f..16081871d943 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 978e5a340faf..dff2374ba9f4 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 99ffb8493390..e48145567f57 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 fb2e77f9d2aa..4793c2870454 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 eb4d5c10c251..f058c61ec3b4 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 2d8936f273fe..ba53a87f84ad 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 3a82d028704b..35087b114684 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 cb1d725ec878..cdff049198d3 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 5fdec1dc74c6..ca3d34661d38 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 8c3aa3429af5..161e8977bf4a 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 db35a20ee222..600028337fa6 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 cfb43ae891fe..05e30f833bb2 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 2ffbc2a434e3..9046502975d4 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 6d96c62545ae..0d0057a79abc 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 9342b269993a..318004da6013 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 fb588854b2a7..938a03757299 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 daebabf45571..ae3be1ed3afb 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 38902e693dc8..2b9260274982 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 36a13b633191..5ac4e23bf015 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 8d7a62c38503..4de90118b4b8 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 7481179f26a0..72db125074b5 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 e47226ecdc7b..448023a2a3d8 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 90210bf7f11a..2d04c0f9be2f 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 701ec6013696..cd842f0eba53 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 9f7638888d64..b70f0ad9950b 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 a57d731f1f71..f6982dc86535 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 07f94f3b91b3..0ffda9e6d631 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); note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for 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 519f6d182d7d..5a2f415bb84b 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 7575300bc575..a7543df340df 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 21e403b47f8d..f526f77a4f00 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 ccfb88909399..7d481940acec 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 b40d99f7bc95..9e9ea710f0e4 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 bd9866acbd4f..7593b8a39987 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 830ab9ca501d..fd4dd502bd5c 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 4be4e8075a72..2d45ae68ca47 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 4b7bdf782368..5ac4f5deffe7 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 3972787a4d2f..3ed823dde942 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::(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 5a7bd80e40c1..314416766a57 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 eeff289dfa4e..c761669c6db4 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::(-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 fb5d3ee1f1f9..34babac4dd33 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 9234b4d705a9..5d27062fbc27 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::(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 63fad1d56e38..f781ca04f033 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 35309e90136c..54781b507e08 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 cf12ab8dbd55..ed34d5255a43 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 c234467bddcb..a1bfa267cbe0 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 8af2d37d74a7..2d8238350f33 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 a9a68177ed97..2add8434ca56 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 4facd2159c8d..d893f7a9e545 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 264465f93919..1d9c89c6880c 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 6df00aefe756..2abe6c6fdf3d 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 cbcb31b29fc3..bc8a140ac22c 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 ea155405cd61..fcd077daa38f 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 e95e3b18128d..3d7ec44fdb06 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 2156886cd71c..55f3f803ad14 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 bbae9cf69ffe..fed1cf458743 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 d35970205f24..9f92853d0ec6 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 e85d76951b64..a28dec2833fa 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 07bf048ab6ec..cda837da7e71 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 f42fb07edcd9..b3f65e7866dc 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 f8b416ec348b..b9495fbd2074 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/74] 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 ca26b649f986..595e4c138b47 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 8961bd4624f4..ab2470210254 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 de04920b8e6f..de55876b1d70 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 e41ace4729d8..0d5b01325994 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 5d8cb707f3fe..9fab02f9631e 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 R + UnwindSafe, R>(f: F) -> Result { = 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 0e2002c34f12..f57b28cbf44c 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 f4bfb94e98ca..1b37249dd60f 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 7ed5ed382471..abcd69d3aaef 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 6c2645ae5bd1..3666007e3d38 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 6c2645ae5bd1..3666007e3d38 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 d2a445f33879..26b4d935ac7c 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>>>() {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 d2a445f33879..26b4d935ac7c 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>>>() {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 c15d19b1594d..a3edf1893560 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 1cbf78173a7a..582a848ca603 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 82de91effe73..8b941d538a25 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 09fd79986958..35a5cabaa671 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 2a4b6f3b76f9..fef6c92af985 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 `>::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 353a9b782240..a6938ca0e905 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 39352ca848a8..533db90ce6c9 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 12cc7fbb1fc6..452ed6b39d28 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 32b67a13061c..cd7549597c71 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 5375ec1188a5..f676d8a75861 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 8a96d187f6b1..cfee8fc44fe0 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 690160577cd9..23b7bf45afbb 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 a94c80eb30b1..795484f11088 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 61fed16294b4..444f3d6689f2 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 for Foo { - impl Into for T where U: From; -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 ccd0040030da..c511081a86ff 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 29eb8c481cde..f048c942f1a7 100644 --- a/tests/ui/infinite/infinite-instantiation.polonius.stderr +++ b/tests/ui/infinite/infinite-instantiation.polonius.stderr @@ -11,5 +11,5 @@ LL | fn function(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 87a7c00e4107..3a94ed7bd3da 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(&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 3a1c0b82c227..08b4573dd0b8 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 776a724d3106..2090530571b3 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 a49475a8570a..59aba4a8ef8b 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 9066e57aabfe..27c07fecd5b5 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 9ab77d3444d0..ca42f87e8194 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 283c01b6b62a..4fb8c2b3aff1 100644 --- a/tests/ui/issues/issue-8727.polonius.stderr +++ b/tests/ui/issues/issue-8727.polonius.stderr @@ -22,5 +22,5 @@ LL | fn generic() { | ^^^^^^^^^^^^^^^ = 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 d1e4e6295a91..1b86b02297f3 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 f9e48a52cb9d..abd65ff3c9eb 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 4448f9326cb9..0d1f9a7690f9 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 0d61311350e8..839626535698 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 476d86cfba9c..613d06cce915 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 4b4fc4fb7d18..ff1a127e63e3 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(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 c727fe551e3b..737e71e88451 100644 --- a/tests/ui/recursion/recursion.polonius.stderr +++ b/tests/ui/recursion/recursion.polonius.stderr @@ -11,5 +11,5 @@ LL | fn test (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 f72b3ab0234e..f2727336bc56 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 8b01941b4c62..4bb420664f7f 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 cc532ccc4510..0c5a06e68b89 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 fb70b987fc7d..d2cf7a0ba1f4 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 9533061892fe..8e65baf65dff 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 2bce9758e997..4b8b90eb6e27 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 b56449299b71..757f1f7994e4 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 3ae901e0dbc9..9dbeee49f534 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 dfd24566953f..7866af594449 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 f69275a01253..d7c7344b596d 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 82d066b2a2fe..bc09f1591832 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(_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/74] 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 cc97971a0ddb..188da67295a1 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 47897dc003a4..2f5be3f7f559 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 86485a9887fb..5f9a5fb76eb4 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 493d74b0bdec..8bb3911241d1 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 = 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 39980ee7c672..392199866654 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 b33f62125454..fcf2565c8ab1 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 7fba8343bc08..50d157c5795e 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 174cd3c28047..840b95d755c6 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 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 a0a8114e0c5c..331483112611 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 dcf4af5df50a..c752a5ee0575 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 From c17444876bcc827e0e4223b193ea40a0f4253b21 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 25 Nov 2023 08:00:32 +0100 Subject: [PATCH 72/74] Preparing for merge from rustc --- src/tools/miri/rust-version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version index ee27d8ed9a86..76ae92279835 100644 --- a/src/tools/miri/rust-version +++ b/src/tools/miri/rust-version @@ -1 +1 @@ -360bafad68cfea2682cf016070e533c45a00150f +34c5ab9aac327a8a18e18ea37a2468a320d82fb0 From 2df4fc0e8b6210b9f2807b26717000f3c69034a4 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 25 Nov 2023 08:03:51 +0100 Subject: [PATCH 73/74] fmt --- src/tools/miri/src/provenance_gc.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/tools/miri/src/provenance_gc.rs b/src/tools/miri/src/provenance_gc.rs index b5106c227400..ab178f82d9fd 100644 --- a/src/tools/miri/src/provenance_gc.rs +++ b/src/tools/miri/src/provenance_gc.rs @@ -194,10 +194,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriInterpCxExt<'mir, 'tcx> { fn remove_unreachable_allocs(&mut self, allocs: FxHashSet) { let this = self.eval_context_mut(); - let allocs = LiveAllocs { - ecx: this, - collected: allocs, - }; + let allocs = LiveAllocs { ecx: this, collected: allocs }; this.machine.allocation_spans.borrow_mut().retain(|id, _| allocs.is_live(*id)); this.machine.intptrcast.borrow_mut().remove_unreachable_allocs(&allocs); if let Some(borrow_tracker) = &this.machine.borrow_tracker { From 34a8680cd50a20e5a2f5a7a6861d7c8b700dc3c6 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 25 Nov 2023 08:27:42 +0100 Subject: [PATCH 74/74] bless --- .../miri/tests/fail-dep/shims/env-set_var-data-race.stderr | 2 +- src/tools/miri/tests/fail/shims/intrinsic_target_feature.stderr | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tools/miri/tests/fail-dep/shims/env-set_var-data-race.stderr b/src/tools/miri/tests/fail-dep/shims/env-set_var-data-race.stderr index a202d7c6844d..b81e8db9e0c9 100644 --- a/src/tools/miri/tests/fail-dep/shims/env-set_var-data-race.stderr +++ b/src/tools/miri/tests/fail-dep/shims/env-set_var-data-race.stderr @@ -16,5 +16,5 @@ LL | env::set_var("MY_RUST_VAR", "Ferris"); note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for 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/intrinsic_target_feature.stderr b/src/tools/miri/tests/fail/shims/intrinsic_target_feature.stderr index c034261338a5..8e83d20854fa 100644 --- a/src/tools/miri/tests/fail/shims/intrinsic_target_feature.stderr +++ b/src/tools/miri/tests/fail/shims/intrinsic_target_feature.stderr @@ -11,5 +11,5 @@ LL | dpps(_mm_setzero_ps(), _mm_setzero_ps(), 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

::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 964709daeda2..e576cd6c7a42 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 592ef7faf813..2c72a8eb5f64 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 64917329c499..969258f84ed6 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 6a47f1ab9832..d2db6abe3132 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) where T: Foo {} | ^^^^ 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 52d8168c9d83..4321d876e163 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 d9caab5875a7..7eaf3b82d981 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, | = 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 d44af5b8dd83..47af270a03a8 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 e9325788961b..061cc7246a71 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 45aa766065e4..b9fb9832086c 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::().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 649b12ce5a5b..5bb2b7f47917 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 ff420eeea4a0..9df991f71b3f 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 1846444b668f..d642e168e18f 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 5b4f5222a2b1..6377d27f4936 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 fce3ff7de78e..3224da58a85f 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 b9ca00974677..996df10a721e 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 ebee09994ba9..ed2964825c7a 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 0fcde9b7cc69..884f3c7b1665 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 98a6a24b3c42..681460ad0812 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 caa5351ddc7a..6e8e4f3b418f 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 64ab892d9972..7d817da13626 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 23d482de6a86..cc01bc46ebd2 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 565e07919bc2..10b86da4fd9e 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 2422c5c3b623..fda28772e429 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 949eb70510e4..c183783493bd 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 225b8e8f32fb..1666f4a3ee81 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 2362c17a0904..931aae96b0ff 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 59a87e139181..b1d79d7c2a2e 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 c4b81118c9f0..124141b65521 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 a04f605edc2e..346d83fa6645 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 2c9ce479b6ca..9f691e396bda 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 c56ee60bb2e6..d5eec9424c82 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 a66e45aa2104..d750443e4a98 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 1b1eda825aae..b18ec9abc374 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 c93aafcfc7cc..d4417a202d5f 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 ade69ced6060..06c7cbcd76da 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 3bba74badbce..b8a680e6a5ca 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 a57c6d9b0cbf..178bfff97d22 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 a57c6d9b0cbf..178bfff97d22 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 f5d607298b79..5cea45060c82 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 23a2f62d9057..80f9330eb818 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(v: Foo, f: fn( as WithAssoc>::Output) -> i32) where 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/auto-traits/issue-84075.stderr b/tests/ui/auto-traits/issue-84075.stderr index 6fbdc669b6ff..943d521ce9e2 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 1cf16cebddd1..e1dae35be006 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() {} | ^^^^^^^^^ 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 80f074103812..23aae13639c7 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 0c4970a72591..aa5585a5371f 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() {} | ^^^^^^^ 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 c575c485a85f..668cbc8aeb43 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() {} | ^^^^^^^ 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 bd7aaf6fb6df..2498af996eab 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::(); | -error: aborting due to 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 06a7e90858ce..19c3c6418198 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> = 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 adda80810ead..e68893a59e49 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 2e8aeebc681d..d1d1d770765e 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 1b7e45c77249..d1d0089ece79 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 f236cd61efe5..20b1ecc5a939 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 8b5cde63c999..82d066f45a4e 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 115e70006198..6ed3e7b44476 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 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 42d910819995..da7f31828264 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 a22f8e3ab0c7..afcfb7b288b8 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 0a98cddfe05a..14739752877c 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 fca042b1c57d..eeb6b028a9a3 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 cfa78a41dbf0..7cce93dca090 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 b3856b6ae168..e58ae0fad9b4 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 75558b502f9d..9bcf2b17357e 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(val: MyType) -> 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 3fdaf4cd0f55..b20a2ee63538 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 68b3f4c1ae2f..2e24ef453c2e 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 63e6d76843d1..b2ae169013a6 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 7f9e80089291..84b273c7338b 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 914886f81b4a..2a94f0a87e18 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 b7427462bcbd..e075dc230d0d 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 7f96aa289d0a..94a4b33da5dd 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 42fb3d3d43d4..25651328e9dc 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 be551f6e889f..c473a84413eb 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 417991e9e0bb..71ca8ffe2a8e 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 4acb955a8e7a..0b79cf0da2a6 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 899ff4261ba3..d94bd489ec60 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 abee72ba8cf9..b9a45edb330c 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 7fd0cb9bb028..0cd6dfe77626 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::(&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 58a42d8afe4d..b5c2b662f315 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 e1fbbc14f44e..73de58649536 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 9e100f8ac3c5..72dfbb797ebc 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 6235e0db0da1..2b16206cd774 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 5abf07a3118d..37386f1c4651 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 7a959fb6ec62..37e98732f1f4 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 88a8867f5ee0..b749779b9482 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 864d933da127..82972b573c6f 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 25d642c30dd9..d14fbd76153b 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 c2dfb687e8ee..0e462256c5a9 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 1a5969586f23..07c09f1f443c 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 71bf052c93d6..dabb5e21fd09 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 a61fdbf6c8f8..199f7c120d8a 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 fa0ae318e72c..0bcf63d6af55 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 6e112e270300..7f0ecf7b3596 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 7ee840b34c52..5d6fc8fa7a33 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 ea93a8f409ce..7c0cda31c973 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 a7a8fc2ff837..0d879c6fb7df 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 e5ee5a401050..105a0b05189e 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 b8bbb31a3550..669dd614f52d 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 30900a3b6d96..bc840577e9b6 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 d2e9497d0795..abd7f19fc955 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 ed7e883ca639..4c3861cfe7ab 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) { | | | 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 acf6b37b7739..6dcd451736df 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 814042539a22..7a1c1510b6a6 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 e7491afdad12..e05696864fdf 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 d48866dce042..ee1bb2a48816 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 fc1a44c3ca04..79519e885d01 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 9eafc2c2a86e..f1fad2d36dc5 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 3f0fe291ca25..c246e41487fc 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 1a20ec85fc00..3f052f8fe3bd 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 2033e4a57301..8171e6950ace 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 1a22b5f0975c..a27b6956b305 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 f1b9b9aa7090..16f4c40f529c 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 39b28811a0c2..f27993e10b44 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 ef0fa6df4fb7..241d24341cb6 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 cec053318364..65de6e8bf5d3 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 4ea4eb8f0075..194403fc17eb 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 850bb9ae3930..6fab19000fcb 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 68a82bdb57c5..abcd14f9a567 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 6cdce7bee889..3e9124bdc27b 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 07b11b3e7282..0c60b094834a 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 de8da490c2e4..d1fbc5b47db1 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 fa5308c29039..3285c7f0ca14 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 93622a0c5f65..5f1e3994af20 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 311369a260d7..838568fd32ca 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 6691a2396a1d..eb11dfa38b8d 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 9d19de211a5e..9c26bc353ab7 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 0fdb1dabbc50..bac9c2790c54 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 6eaa1fa31693..01647011207f 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`, 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 4f0202f38324..a41c4af98e7c 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 43fc102bd625..7213f85ad98f 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 9509ebb7cde9..6a77d86f250a 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 e1e3c7f8aaa5..88eb6c8ceeee 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 934dd8df1d2d..02794a12fad6 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 599fa1e88dfe..dce1f4d0775e 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 edf8c954f816..07dcaf875e70 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 9ff20a1f46a1..4fa23f16bfdb 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 341146bd18fd..8408d99156a3 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 20528e3f0ee0..84f35dc2249e 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 8ab472e64c7a..823f470ce8ef 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 3462b7610d38..bde43a90850b 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 16d66bf40d10..7b43f2aee30e 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 7f42becd21c2..7b2cac987960 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 f5f4817e9bf3..b4106702cd1a 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 36a871fbb12a..e25ca082b7b5 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 05f5411eed68..291737952388 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 d12a482cb69a..4833e689c19b 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 b86a8693881a..387c681fddfa 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 f28c42ce2d58..65748d844fa1 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 5cfd81bd0042..5f319112b86e 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 { | +++ -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 f785900d53fc..16047efa32bf 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 d54449ac4ad4..eade7d1ea95c 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 9799357c9ca1..a1bc3008ea8c 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 3a413153acd1..a08e2a7b5352 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 1c55953c91fb..225a983bab44 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 2f397f6b5853..11ee8f7bb91a 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 f3b962059f5b..e6c3869f67ae 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 071598b42eec..06bb419aa3b3 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 eeafc4ce191c..213b541b8a92 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 f2e549cd88c9..68a950dfdaaf 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 af6f6fac4087..8c0239a3ae91 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 55f3ff553c13..dcbaa75333e0 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 ea3d0d3ef51c..7ccf6a4c3fc8 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 5141fcc1bb26..d5964d28b083 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 494d8c351a15..03a7efacb332 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 7e21c55f21b5..2187437a1cd2 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 13143d436df8..e91af728b649 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 5d0194989563..2d92b45e02a6 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 c45235990c38..d560b9c02fb6 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 85785e670729..5a55088d67ac 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 b344aa664051..3a801a22ea2b 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 78ca090feb72..879ff8be0e88 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 d5734e7ec977..98dae19a7d44 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 bddb0633a0b8..84a480f64107 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 89391f4099a2..a97f2bdd4c9b 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 a22afdc67648..1f32ece3d3d2 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 4a237835222f..b7ece5d971d8 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 = 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 2720b09b0fc5..211d4cb3e4bd 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 7e0fc2cf298b..40ab2e61d6a4 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 3ae7e64d202b..45e977e39477 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 65aea5b1834b..5ca0a7fb8853 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 27dab53e48fd..e2efc405faba 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 f77fdbf2b6bf..41c9d6aac760 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 a6357f8182fc..47c78d6863b5 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 716cc9d0c8ba..8585376b92dd 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 5cffa1b51219..bf82d462b51b 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 feb098c59858..19a4a98bb1f4 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 935414c1f3f9..17e4b5e8dcfb 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 8d4918867f75..d6aeb410ec4d 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 d82e1f908cb8..85adfc03d107 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 f8a9608ad373..d19fa18dfb63 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 6ec920cb81f3..c0b06437093a 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 0d486b45592b..e51e0b33ebd3 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 3f7715645e60..ac4936bac4bc 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 3debfb62c3f9..5887752800b5 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 99c63e4db50d..121c2e870e7a 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 967451c68bea..630d07d652b3 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 8fe8fa710643..e19f37538c16 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 19f194100a19..466f19eb0ab9 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::>(); | ~~~~~~~~ -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 369a8c61d2c9..87b8e0591352 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 9d86286b8676..07a67474c831 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 0d803b0427ac..94566ae19516 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 2bbde82fafdf..7681ee68c0f2 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 5f7e86f11dcd..f1f28dcceb03 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 d9aeaf15f200..f55da67a85bc 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 0c0d1994baff..f1c24640c132 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 98093daa9452..c0dae0de3281 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 094cec021e46..06c2ea5ab720 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 e61dc95ecc8f..e52ebf9382c9 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 0565127e3875..1933f5bd8d27 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 0ca732ff2ae4..ab9f71cc00ce 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 4d305268a0b3..f0aefd7ba877 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 5ff33933cf09..1da573ea97c1 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 f272477a9f5b..2ac785cd1e3b 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 a2c291f77979..8cb4583eba94 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 26ce007dd346..4e7a9b695e17 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 572414df2bf9..c37de178f249 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 29c0429f2a04..80f1f4cb5091 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>` -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 afd141125ac7..a15909df07bf 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 7b785b25bd05..b32331ce448e 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 9732b8cfa4da..e3c881dd4650 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 30f83656518d..f96b0c7d9e1a 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 = 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 ea4f9abb87d9..167a5cf5863c 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 a46b1288911d..0ffedccd6906 100644 --- a/tests/ui/borrowck/issue-92157.stderr +++ b/tests/ui/borrowck/issue-92157.stderr @@ -7,6 +7,6 @@ LL | fn start(_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 bcbcbe724127..446b4582bfb9 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 afa76594f0b5..b6a2768b61da 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 0f808ac92761..bc2ba987c9dc 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 38dba94bdd41..0d5edadcb464 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 a4432e38da0e..03c0297c5a98 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 8ac711e9e59d..83f9e19aa0d5 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 55948afca733..bfbae5be050a 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 74e7067c9afa..7b9a946f3ca3 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 ecd916a59fcb..8590dd9ca3d0 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 14393bc8eeed..9c070de44571 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 a23fdacdee64..868ba9c89be2 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 153f77c8913a..c861f772be0d 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 9f952542e18b..1f4a548a4cb0 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 c8d00f7b2227..d88e8b09687d 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 77f991a9a61c..b396bb7b5ec4 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 368d728101c2..a69a025cbcbc 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 b276ea9acebe..a5c448fdcdbe 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 d7c0210cc77f..bd63fc961264 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 2c3f1c18a084..6a3e0db4be63 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 e3e4057d6a78..b1e4392989fe 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 4db970c1da06..4f1712ccc009 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 a2f6365b74e6..fd168b43ac5c 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 03ae36e88901..352efce318f3 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 = Box::new(10); = note: see issue #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 c03f35884b8a..568d23c2cb79 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 feda8841fc8d..8b8cea3fe849 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 db42ed9baf1e..1b98d09ccddb 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: 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 2fd5b0d82e8f..d662a2d6d051 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 c8d4fd59550f..0b8c77cb9e10 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 26f2a4c4b291..cc465fbf3def 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 d405e465aaee..805c2112bdc1 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 f9d548bb8fbe..251651df4f90 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 RequiresRequiresShareAndSend for 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/builtin-superkinds/builtin-superkinds-self-type.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr index 0e2c6c60b6e3..d0102635315f 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 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 8b19170b0f10..7579bffc72d7 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 0cfea72d5f18..4a25c42b5835 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 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 cedb58784662..352db9f62f6d 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 815b06e77089..2c4be2522f61 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 8884fc6fb2af..d0ca7034ba1c 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 4c7792d96501..1ceff5704786 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 e11ba43ca2a9..e268ef3fa681 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 ad8434709d5e..067b85ba6191 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 1e77f5dbdc64..658d5ddbb611 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 dab133cfb4b6..991ff93a8bd0 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 db7ce57e1506..83c6cf31faae 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 dd90c3a97231..b7fb420533e6 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 29a9baffd71d..14c75983b94c 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 f9abfb5225f9..8ddd97137c30 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 84175473696d..84bc73a9b786 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 5b8a18233869..52afc8343e1e 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 1097079dfc1d..0d4f6f194318 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 ed8a6fc62e9d..847a5527dda1 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 886145c1bafe..0459ce5eabde 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 bf3c3537fade..1208ca45d50e 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 79b3d973c32f..47a51d846525 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 56a375a1d942..2c4951ec7b18 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 b3f921c14edb..541d15d021d3 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 af0e1a172757..6941f850e5f7 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 a32a94c1315a..402f9032b640 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 56d10d88d8b2..4ea0f41c3ed9 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` in the cur LL | nyan.eat(); | ^^^ method not found in `Box` -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 3b4ac3a9adc5..42bd22e18a19 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 c5089295063d..d3cd8185f924 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) 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 7a04ed7381e6..8799a2a0772f 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 eeb409452424..0b58180bcca7 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 24773a1d7e35..66fb1856cbbb 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 + '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 896bb6dc6bee..9ae89047d128 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 341d2bc65634..f59a2625cd2c 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 584bb862b2c0..64d5ff8e2e0c 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 ee9238047868..979527e9f793 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 46379a3815a4..d47f0539b84b 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 5f1dae2972f9..57234fffec64 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 38c530b809a6..d224f21bc849 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 309c63e52932..1172f54c1508 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: 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 83d282aadb91..347fa3fa8920 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 46323b75210c..c9b27e768795 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 25029cc7bd8b..079a9abedf97 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 06ef7baf9c06..0bf717404ceb 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 3e77635f9e0c..4abe5eda22d7 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: 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 ac4c9c93769c..5a054ef5fdcd 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 8c44229bcebe..c9972c8e7e34 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 06157b2af7a0..68fdb3ce131f 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 17834e612362..63fb3e5d9753 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 c1679c6b637e..ccca24764e42 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 1e42d73c62bd..d82db0481a06 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 c17edce72f98..7ea5136d1191 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 e10898f98449..2b76deca3770 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 730823281abc..e4b5d39c0b1f 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 66ba0fe3547a..c18649b9ee9d 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 6f9c309edda2..d095e59c7ebb 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 c016465c101c..9c4fd95ed76e 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 || -> () {}; | ^^^^^^^^^^^^ -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 59f299315f85..d38b233d99a8 100644 --- a/tests/ui/closures/binder/disallow-const.stderr +++ b/tests/ui/closures/binder/disallow-const.stderr @@ -7,6 +7,6 @@ LL | for || -> () {}; = note: see issue #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 3370e21bd711..bc6696ad36b4 100644 --- a/tests/ui/closures/binder/disallow-ty.stderr +++ b/tests/ui/closures/binder/disallow-ty.stderr @@ -7,6 +7,6 @@ LL | for || -> () {}; = note: see issue #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 35db34ce21d1..ff39e8841ee7 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 14b2dbf03957..6609b326f19a 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 || -> () {}; | ^ -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 ef00a2dffcea..22431130a5d4 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 {}; | ^ -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 9ecc66d5ce89..7c73372e33c9 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 d7fafc8cadd7..686bbab88395 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 bf6ec5c36e48..e98f05b470e7 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(blk: F) -> X 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 8ad8273fc2b9..42588668e8a0 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) 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 565038f5144e..6b309d70bdf1 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::::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 799097889cd3..23bd0020db6b 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 aee903ac9504..2bb26b0c0b7d 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 87e670bb0b39..8fab92e9b151 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 7c7e9d0ce125..06682fcc244a 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 276e766e8065..bbf3677fb723 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 0bec11ab61fc..c86731b127d3 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 13d19495d23d..ffe01fac4966 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 8ca43cd1cffb..6fe6840b35b3 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 6bb59813157b..426930666065 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 9ea55d764f34..705cc948668f 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) {} | ^^^^^^^ 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 a60100ddaeae..579227703103 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 8c516e8900c2..fb237231d65a 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 bd4ab13a205f..4841ff32e701 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::::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 97351706699a..0866265cf048 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 423b79dafcc9..bcbcd6d4c2d8 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`, 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 d86b05dc6a7b..f47ea6072976 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 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 8ccef4a54f5d..c51d13f4ad0f 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 c814eedd2261..04921b9227e0 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 5e889e6c1844..19a26396a5d9 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) -> i32 where F: Fn(Helper, 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 7877c7334d79..bdafeaef15fd 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: 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 6a40db0d51d4..aed673fe1ab5 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 239f071ca92b..1266c603e5d8 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 1ec279f03eff..57320b58d015 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 22a62ce73505..b605cd2f9e51 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 a2222f8cc957..b0210ac7cb72 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 03b18c3f70c6..d050fb60c3db 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 f0951b7d1087..c6ed7097c5d4 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 5335a056cd89..ada0e337324e 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 1cd8949b8c4b..9d4c7f715811 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); | ^^^ -error: aborting due to 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 0d940aa9a2f5..e48f5106165b 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::(|| {}); | ++++++++ -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 d94c902f7214..d510fc585f65 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 bc54ab4d511a..c6ce1c62d93e 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 2697f93b14c2..41cad279f7b9 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 ced0be9458b8..0a604a7d6cf0 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 6e3659b95ea8..1a13255429f0 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 5e8a6b1a73aa..75aa3c934799 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 f1fc35e755cc..8553817247d5 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 3f9160fe5fa9..3d0af5eb171c 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 ed8e16899a16..0a5884d38f78 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:: 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 37230078781e..a8aced2483e8 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: :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 08b763b26082..8d1b10eaeb5b 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 3ade9891e48a..917098e21d82 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 426d82d8d075..26d3bfe78375 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 1054c2665127..cfbdda509e58 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: :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 7e8862f9ab7f..3e6954394f44 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 36d76c9674ad..4d34f0d75099 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 2c1c3c2dc967..917ea7330a18 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 e36f59ee5463..32f51c95d440 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 9f8ce3b6183f..d2923875c94c 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 d0c29c768eb6..5d0cf718761c 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 7daa0510cfa1..efd8fa22fa5c 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 75fbbada72ce..90762b87b5cd 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 0bfdc3ac2651..4f9a937155dd 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 b17159be6e06..7ae21a57052f 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 2eb3fd567831..d833d4944bfe 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 05ceb6910dad..a6e22e1c38f9 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 90eb75f2bdfd..89682e103aa5 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 7e14f42eaafc..6a6f5ec11b9f 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 da3c387773f9..bf2c3899925f 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::(&*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 3cfebb8a5437..e98b3e610a8b 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 7044fc3cefc4..1301f3b7813e 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 11a4f310154c..9bbfcc29e61a 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 5cbdef218311..498ef33d52ec 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(_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 17bbca7a0bdb..26a7a5c1cdd8 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 4778611bf1b5..af114519add6 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 CoerceUnsized> for Foo {} | +++++++++ -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 798ce1199a9d..dac21a7f25b2 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>` found enum `Option<&dyn Iterator + 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 7eca41753395..0cf9f87b40ac 100644 --- a/tests/ui/coherence/coherence-all-remote.stderr +++ b/tests/ui/coherence/coherence-all-remote.stderr @@ -7,6 +7,6 @@ LL | impl Remote1 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 e8d74c917e46..e6c77624a8e8 100644 --- a/tests/ui/coherence/coherence-bigint-param.stderr +++ b/tests/ui/coherence/coherence-bigint-param.stderr @@ -7,6 +7,6 @@ LL | impl Remote1 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 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 9156972a1df9..3618fe841b13 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 MyTrait for T { LL | impl 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 8400968e1227..510480f6a045 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 MyTrait for T { LL | impl 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 4d7872598b1e..4b86cffbe479 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 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 c2a925213da2..ddb7474c2899 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 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-trait.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr index e1a5dffebdaa..b681285341bf 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 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 ba60a2ea9294..164edff4a7b6 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 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 fe4b5b410789..0bc017817b67 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 Remote for Pair> { } | = 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 da4ede3251ed..9bdb49dcc04f 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 Remote for Pair,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 d1a20c0ca101..dfff2667ebbc 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 Remote for Pair,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 3d253d56a456..812ce97721cc 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 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 aadc80cb1c3e..fcaa510c632a 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 7dabd97b94e8..316da26b54d4 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 2018712043e2..b0dea7467092 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 82bd8a35f457..246ec5947b3e 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 e2d84b833200..c97b32e429d3 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 a35a95ef4bfa..db6a94748042 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 {} | = 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 684e528220f8..9f813d6d5716 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 { 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 f60b2aa2735d..5c5753939049 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 ef5b08836538..48d25bba8d71 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 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 1bd37f395902..759e50c3bea4 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 6d6e163b2066..dbb22d8937d5 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 6d6e163b2066..dbb22d8937d5 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 8a43ad7b7f0e..ca8d7a5c4c3b 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 MyTrait for T {} LL | impl 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 6a0880334b6e..a6e47d9f92e7 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 From for T { LL | impl 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 c02a679c149c..2f3ad6278088 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 Cake> { 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 c02a679c149c..2f3ad6278088 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 Cake> { 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 a4e87af8ac40..b94947740254 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 Sweet for Box { } | = 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 a4e87af8ac40..b94947740254 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 Sweet for Box { } | = 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 4b55001ecc0e..21c82eedd5df 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 Foo for T {} LL | impl 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 687f3af00403..4f277ad68a67 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 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 f355c6e855ce..65885ecac41e 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 { 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 8272c8875860..212ef484afc4 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 15c92dfeb07d..4d0a9c6ee140 100644 --- a/tests/ui/coherence/coherence-overlapping-pairs.stderr +++ b/tests/ui/coherence/coherence-overlapping-pairs.stderr @@ -9,6 +9,6 @@ LL | impl Remote for lib::Pair { } | = 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 03d787123812..15cd66e9d09d 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 Remote1>> 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 73dfe2f572ae..359dbe8509d8 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 Remote for Pair> { } | = 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 b1ee0795b2eb..976018993055 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 Foo 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 94d242eaac43..f074467bbaa7 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 Foo for Option { } | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 7d2c584c3706..c916091e62db 100644 --- a/tests/ui/coherence/coherence-projection-conflict.stderr +++ b/tests/ui/coherence/coherence-projection-conflict.stderr @@ -7,6 +7,6 @@ LL | LL | impl Foo 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 09ad5e5b2243..4e02c0eb43c7 100644 --- a/tests/ui/coherence/coherence-tuple-conflict.stderr +++ b/tests/ui/coherence/coherence-tuple-conflict.stderr @@ -7,6 +7,6 @@ LL | impl MyTrait for (T,T) { LL | impl 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 a3a37fd27757..4f898ec127b9 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: 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 95fdf172ec25..e4249710d002 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 Remote for Vec> { } | = 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 4835e771abd3..c465fb1966eb 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 { } | = 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 600cd42d8c69..b3c3dac612db 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 431108e14d7d..501279ffe6a7 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 {} LL | impl Trait for Wrapper {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Wrapper` -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 b2a9135c542f..9cf20ea49364 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 {} LL | impl Trait for Wrapper {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Wrapper` -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 93486fa5f360..50bbe12bc20a 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 7432733b932a..715a825ceb07 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 { } | = note: upstream crates may add a new impl of trait `lib::MyCopy` for type `lib::MyStruct` 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 090497ec1897..fbd293dba9ae 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 b381b0680734..da8c03847eda 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 7b6cb7d4390b..d34f6fa213be 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 afc6fc45d0e0..96572b5a7164 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 { } | = 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 a4953859f77f..85a063bb34ae 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 7b6dd4b380f6..e79abe35597d 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>` requires that `OpaqueListCo LL | pub struct List<'tcx, T>(Interned<'tcx, ListS>); | ^^^^^^^^^^^^^^^^^^^^^^^^ -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 8fed9ba23b24..2a74cb5a9b8b 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 93f7a6fdc25d..6c74b47a1c48 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 65b3aa394a85..fe8a34b78cfd 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 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 249a5c44c79c..12d9a807f492 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 Remote for Box { = 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 aed184767a0b..6ca3ccd05feb 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 Remote1 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 d97e85dcb3c3..1f3463e88371 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 Remote1 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 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 44e3b7eedb40..a1f3936497e6 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 Remote1 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 ff72969dc52a..acd84f7115f5 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 Remote1 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 9b2dbc66ca7f..74be598c44c7 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, | = 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 9b2dbc66ca7f..74be598c44c7 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, | = 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 52d36c92f996..f515c39ea8d1 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 Bar for T where T: Foo {} LL | impl Bar for Box {} | ^^^^^^^^^^^^^^^^^^^^^^ 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 442934a89492..f24de10f6ac4 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 Bar for T where T: Foo {} LL | impl 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 34f3904443c3..5368db293383 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 b5472928778e..82804e8baac4 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 4f32639a6310..4535b6f68115 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>` for `Interval<_>` will conflict in the future diff --git a/tests/ui/command-line-diagnostics.stderr b/tests/ui/command-line-diagnostics.stderr index 6223ad880d69..b719a00ad5dd 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 305f76694f71..89f7210c048e 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 797a8167931f..b349e24f589b 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 eb19d57ab05a..3f55f6731176 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 1a471e18d9dc..065b3c152edc 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 f7ae6f94438e..75a4d51ce8fb 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 1552d542d15d..8a439acee13d 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(&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 ce6885c1541f..0899d5406f99 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(&self, x: C) -> C; LL | fn b(&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 36bb764d40eb..b8d3fd02ab5a 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>(self, other: U) -> ZipIterator; LL | fn zip>(self, other: U) -> ZipIterator { | ^^^^^^^^^^^ impl has extra requirement `U: 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/compile_error_macro.stderr b/tests/ui/compile_error_macro.stderr index 91ebcaa6e9de..92d5564e8a7c 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 d61872c48ea9..5f7fea0965f6 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 4997ca4db27c..82dc43619990 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 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 96c571ebebdb..2033894b3b4f 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 c8762d15d942..daba4eb1a63d 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 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 e75b1c5b4c87..675792d2e321 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 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 fc8df6552c3e..c91ad128d6e5 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 ff72c43efbd0..98be6d01f1bb 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 33af7d62548e..22ed1c5a39ec 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 2f55b9559c78..f03441909767 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 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 c35fe2f9458d..9715f16acc20 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 1c9a6847ceb4..a51fd4f02aab 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 4b96bce8d2e8..3d860d8c85a1 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 783378f8db58..142c84504276 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 63a4df242f85..eecdb6f92667 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 { | = 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 ef55242df874..1177965d0d2c 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() {} | ^^^^^^^^^^^^^^^^^^^^^^^^^ 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 e5e7ee26e44b..602a8927a853 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; | ^^^^^^ 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 25701ce68ccc..d60d8ec0e90d 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 bd24f9140e4e..6f5bc567c378 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 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 4e12f7a8c6e6..e91b885803ee 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() -> Array { | ^ -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 310ca75fdc90..52b7f2a37de8 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 a345c48b088c..4cea35f1c8eb 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 2c7a47bbc78c..8f8c87afe851 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(_: &'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 c5160d1c3848..55bced29aff1 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(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 e508890dd7c8..2bfa604fc567 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([(); 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 e508890dd7c8..2bfa604fc567 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([(); 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 f7ec4d57401c..a05554d7a367 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>() {} | = 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 efaa182852ac..2a5ca5d39cea 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 4b2b05742538..691e0354eddc 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 Foo {} | ^^^^^^^^^^^^^^^^^^ -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 4259ce2b626f..35aae4624437 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; | ^^^^^^^ 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 4259ce2b626f..35aae4624437 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; | ^^^^^^^ 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 a61411d6eb6e..65ee0ecfdc5a 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 = 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 61b3551182c9..fbf1adfb7a52 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 e83f89a60333..25b3fed0daff 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:: = 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 ba08b4646d0f..bf2b21c012d4 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(&'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 170c1f7f7b2a..be67ea3f5039 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 {} | | | 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 eba1768f7dda..8a72b5aff6de 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 eba1768f7dda..8a72b5aff6de 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 4c5b5ada4f13..e185474f5bd8 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 b3a275660260..4e9e001f2c1a 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 4ce1be25edb9..ca4db8e28dad 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 826f2657905d..faba4ce10a1b 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 625338bd9b4a..3ae2c9c8e60b 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() -> 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 ab2871ff2812..a6f362308200 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 deb65ddba708..42814c1fb705 100644 --- a/tests/ui/const-generics/exhaustive-value.stderr +++ b/tests/ui/const-generics/exhaustive-value.stderr @@ -15,6 +15,6 @@ LL | <() as Foo>::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 6fe5390471dd..cae4806368a9 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() {} | ^^^ -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 aeb19dc75322..eccf9059ee33 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() {} | = 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 2d66a1923326..48d4a45345af 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 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 a7afa4842759..f6d41809d67d 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 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 c124010aab05..ad32a688c03f 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 0efb9e9d3c28..94afded9469e 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 d0776d49d71b..be6b3b90ec72 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 0096d4ee23d1..c42226b77f53 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 d48b639dbdee..4b76ae6cfd56 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 e4a0cabe5728..a8657bf5263a 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 45d7922bd0b8..e245a6dab25f 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() -> [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 f26259908401..a85e0cbcf7e9 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::() }]; = 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 2d9de8805bb5..043fa34d605a 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 2d60ebaa83a1..3b456324819b 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 = [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 bd71b49ee238..080e920258dc 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() -> [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 827dd59d9ad3..09b618fb3f05 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 42671412fa77..ef9ee6d7cfc1 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 302da59651cc..2cec51cce228 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 511ae58a1dcd..08ecb2e48664 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::()]; = help: consider constraining the associated type `::Assoc` to `[(); std::mem::size_of::()]` or calling a method that returns `::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 9b66fc502b72..8d59235e2f44 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 `::{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 dc7d0c54fcc9..b57779739a55 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 8b6eb5b75940..1036b7261f26 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 = ()>>() {} | ^^^^ -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 7b41e39b7d74..395088bf2f29 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::(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/no_where_clause.stderr b/tests/ui/const-generics/generic_const_exprs/no_where_clause.stderr index 3e5c2f5cad1d..100cf3f8b629 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 3926c830adb7..7d84d7bcae7b 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::(); = 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 b7ec657120c6..272d3e74b9cb 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::()]; = 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 440cf457e196..9e480ce9b856 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 59e9fee1eaf4..e800c5d059f4 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::(&()); | +++++ -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 63e6fcc8e119..eba8b9b6257e 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() LL | Is<{ std::mem::size_of::() == 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 0314d7ed23d3..c73d1022ed31 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 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 8cbd12654480..3bae93ccb83f 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 976f037062dd..67eed46eaddc 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 1db62c57fd43..5a39a5724211 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 a72f5800a07c..5d3ef008b16e 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 93e45a88a6c2..e3caefef10f8 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::(); | +++++ -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 1682b26ac877..5b411269862a 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::(&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 f527ee6e4f55..2def9e85ab75 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::(); | +++++ -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 cf70c2181395..3e33fec9cefe 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 20daf45706bf..0ec6ac9c22e5 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::(); | ++++++++ -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 2545cc6f3964..158b9722ee61 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 aabe4c93b362..f631e1311460 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` found reference `&Foo 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 bd8a4feeff5e..0bd3f6eddd45 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 946d5148667e..404e3839bca9 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(5) }>` found struct `Test(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 3b7143de543d..b21ad3aec795 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 18370eea5714..a87b59940cb8 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 5fc0ec260474..86eb57355bd6 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 770c80cbbd30..351dcb1a1557 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 f1c49eecfb54..96b68ca22f4f 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 5bb356696236..0af6f87a68df 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(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 8d9e545b4568..4132e511240a 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(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 c658b5a6e686..615bfeb65a51 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() {} | = 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 e2d8c5ca0e14..5082705927ee 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() { | = 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 9d80f1cd01bc..b9588e23e55c 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() { = 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 13cb8d1cd686..96e0f1b0e1fc 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 f1a426c3c586..bdf05023d5f0 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::()]; | = help: try adding a `where` bound using this expression: `where [(); mem::size_of::()]:` -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 dcbe5b94a628..14037b9eea5a 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::()]; | = 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 ee17ec3c698b..2ecdc0366d55 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 47429b7612f9..837927d588c7 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 6e07af1e672a..62fbed71aef5 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> = 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 98f9f83976aa..9683769aa240 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 c03d40a7bb83..5450cabef614 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 c8b9f17196ac..20962098bfff 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 {} = 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 fc6cef9d44e5..8c76f9b5d65c 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 {} = 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 ccdfbbd54cfb..9553be6fc07c 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() {} | = 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 277540610864..2aa9e344067b 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] = []; >::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 ab2a4e64a838..95faa406f859 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(&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 217166d84793..0c58b10c0b7c 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(&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 b55f410a0237..6f6a9fc21a69 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(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 92580b33685d..cc46e7951f0a 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 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 b010996b8969..cd009c973aeb 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 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 631c8605fb4d..9ab18c3a53de 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 Foo for T { LL | impl 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 fdf057bdbe47..64df76756ac3 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() {} = 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 bed0a02a7267..2b33f35defd0 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() {} = 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 affeca167e97..63d8fc12fa44 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() {} = 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 e316b4624a00..1d7ac1b01111 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::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 ba7fd2ca3ccf..1e7878e8da95 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::()}>: 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 754f18d5cc42..5f53dca4bedf 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::()]; = 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 5409002a9fde..6abbf1c0f759 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([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 d70c8d0bfbf3..d0fc7112426a 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 5187434ff40e..f41115ce4276 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 bcfd70639896..91451a799b0c 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 df734933c250..d9956875cf88 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 2dfc48a34e4b..796c5515e045 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 d02808f7c567..aa8aa4e10a81 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 3a9cd957f35e..2928c1923b8b 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(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 23424d7b919b..6c00a654cde7 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) | = 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 724d7f42e69d..1db906095727 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 31e92f840e18..47e6bf1df4d1 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 4a248be76a9e..e7582aaae11a 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 21c8fe6865cc..7bef98b1d5d2 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 a66dc8db9144..5edbf7bc0406 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 0d5a393cb7bf..b800c6d77b0a 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 { | ^ -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 dedad2880c9e..247eea3d9899 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() {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 bda885970068..03c76150010f 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 BindsParam for ::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 41546292c47d..4943f0d70bd0 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 Baz for Bar { | ^^^^^^ -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 6d9f4406504e..04dc84ea3cf5 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 6b8e688fba8d..1a251044ec07 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 61d055e80847..8c66c4fefb7e 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: Bar; | ^^^^^^ 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 9532fc21a31b..4b1b9f20559e 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 fd8f8b2693a4..bcb59705c6b2 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 5685eedbdeca..1e33439f6d73 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 be289f44f1b6..1b3a54923284 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 6b0d18f1989a..5a947677678d 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 87ff7babe71c..07da6ede7251 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(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 1de24bff4692..be3d4f6d25c1 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 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 f0d0d90c774f..c46c305e0850 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 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 9f727231edfb..88672bce0a7e 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::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 69f1aae5681a..aef95bdaa880 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; | ^^^^^^^^^^ -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 13fbc34e51a0..4de98191d5b7 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; | = 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 67f497af5050..734a42fe5266 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(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 f18e149464d3..25bb7ac80396 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; = 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 3f42feea562a..69fd6f1c7d53 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 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 70bc64057989..4fce1aede954 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 70bc64057989..4fce1aede954 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 d4d78b596278..e050254a3e9d 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::(); | +++++ -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 0f462dd4728f..2e8210772e94 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 807065ca109e..6e985f56666b 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; = 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 658a84066087..2f8dfc895b27 100644 --- a/tests/ui/const-generics/wrong-normalization.stderr +++ b/tests/ui/const-generics/wrong-normalization.stderr @@ -6,6 +6,6 @@ LL | impl 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 3bcf2b2de7bd..8a0f831ba847 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 2b65ffc2db76..593b0b94ca2d 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 793da6285877..9af1f7e3a241 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 22fec638970a..a11506ecb6d6 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 854b9ce5b223..d826972ce9f5 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 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 8c6364aeca60..8228fa29edf1 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 f1c5f58af47d..d481d7728940 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 6c51ed89393a..8d30321e3734 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 b402f0ea9154..81790a62f61d 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(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 eb8b8ac75343..b13df67b423b 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 = no_copy(); LL ~ let _: [Option; 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 858ffa820e21..36249bf3f6d4 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 = 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 e46bcad0e1d0..4e7098a5c8fa 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 ee186636e4eb..44361f15d8a9 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 16eb6b0162dd..b102b4d17cca 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 1ad504b3a80d..2fe0b9bb463a 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 1cbf78173a7a..582a848ca603 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 4b6784acfcf0..5300111a6b6b 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 c3401fbaefee..300343780797 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 ed6a6ee6e0fd..d533dcaa6f6b 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::(); 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 73f421b5b146..0437cd3adb41 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 94f4193195c2..ce5e59901c13 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 fe33ad4905a5..ba11759a7106 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 36918b52cd3a..0c7c69b794aa 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 82c63dd176d4..5f4af25611f0 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 9e8179181fd0..aad36b52b011 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 846458176d6f..a7df82705b88 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 0e31520fdbb0..bd25e96c2cf1 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::::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 4ca44694cd78..6a5839e3dfb4 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::::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 23ba2c2f5351..cdde14756e47 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 2103f842bd58..dfaecfbcd8f1 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 de23aafe05cc..5ef034270936 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 b6276647350b..3903ccd6ade7 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 916344a7b816..d2d323e5a515 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 8bcd03005981..4e7ef52f674a 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 8bb3a0c67d65..d8df74fa0103 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 d247d691dbb1..64c87af43088 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 f0434a847cea..e7a0a96a1e60 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 eea42c8ce451..6aabe53011c9 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!("{}", 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 2022a16e789e..485a11d1f3c6 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 6454ce3d1ae1..f3ec3200f946 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 | & 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 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 c6b1df6c8f4d..f552c8fde5bc 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 48a20d0bbd08..65c49956f185 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::` 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 ebf9d12a66ad..daaee03787f4 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 572a430726fb..7cece4ed5d6c 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 3d2c76b7ed04..a88e959a8a65 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 fd7b40572c1b..519227bc6937 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 d04fdb70ed30..1add81406037 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 05c3951c1284..1e14c70fcf10 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 d127d1d455bd..901ae1922c74 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 e34f3f43c64d..b878c8d1b376 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 50660664f87f..eef39255927a 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 6bff14a45b1c..d3ba3eefb1ab 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 b948e07b92db..3203ca764bb0 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 2d4e7c83d3e4..9aec54793977 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 9ebae3a18a32..71e10478982c 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 e8d4076a61a2..901bfa10ee85 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 abe6410465e4..ff09f5aee1c7 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::()]; = 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 a3fd712ca460..f087c9960c28 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 5808ee35a6b4..ecb48fc62a3d 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 524c8e554266..a05d792c95ca 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 434a957f6484..3603db03bb20 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 09fd79986958..35a5cabaa671 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 5750212b44c8..2a133c057b3e 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 403fb5e09404..de96821e8b98 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 097f6b049dc8..ef2545b43b17 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 b299208ae815..b1de225ec580 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 42f17de20034..49a285f844fd 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 cdb70a69dfd8..c2cf2f3813c5 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 fbb10feb76b1..fd0ee316fe24 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 759ce15ab1b5..d7330beca7b5 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 5ec9e2a91f1d..aaa8dfa8dca5 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 ec415ec9d021..82074867b269 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 81f6c09ffb86..63f81ea18bc0 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 a23d81c0ebec..f0c6c69eac4e 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 a86a06b3ef19..beaf52c0cfb3 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 2ea377e09f61..0c24bbad7dd4 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 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 b7b5b648c124..bd2a81f51483 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 b7b5b648c124..bd2a81f51483 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 68e958b378da..bfec056cc8aa 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 27ff5d4cd5c6..84890214861b 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 0c74a7b3dd4d..0aa12eb86ddd 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 3f9bd37053a0..7d8d062dbbed 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 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 86506e6ca010..2bebfbfda01a 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 83448c3e8d87..c3cc69830dfd 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 46b432357aae..a5679400c2f0 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 746883a79a65..30ec340d2a23 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 3bc1eacf32f9..d4a42a880e32 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 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 cd1a06304320..79c6ec108b96 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 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 d5df0df9525c..792e18aa8fd4 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 d2cbe4550f4b..fee22a1d070b 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::::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 ae24f8f65009..e1b8154a287e 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 be144a87b8b3..4ecfb3f1c5a4 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 5ec68719a973..719295c96a5b 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 cced6af499f1..1979c297ae44 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 958bf373cf40..d3628a8decb1 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 d6119028f5b5..5aedfb03f6cb 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 593a51bfe8fe..6394563e2bb8 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 8b1ca183de98..2f863daf760d 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 66227f61e356..69bf78839be7 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 a931c89f47e7..1556c6f9c558 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 5aeec8fbf866..7351f5c0a6f9 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 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 fa20077da7ef..24572040b910 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, const N: usize> 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/consts/dangling-alloc-id-ice.stderr b/tests/ui/consts/dangling-alloc-id-ice.stderr index 0a1cca4ca4d4..e14204c09e54 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 bdfe1e4effe3..5a428355034a 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 62324939b08a..3f4b6f348262 100644 --- a/tests/ui/consts/drop_box.stderr +++ b/tests/ui/consts/drop_box.stderr @@ -6,6 +6,6 @@ LL | const fn f(_: Box) {} | | | 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 37758a4cbda6..e3c6785290d7 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 d26ae2cee1c9..a943c84e3b2a 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 3bb1360166a1..27a2c23a6788 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 65a828d118c0..0f71ab4b97f0 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 b32b6398ece6..e3143080c5fc 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 fcbb3724567f..8ade68eb2a97 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 3be658359461..b8944abba266 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 257ecd7f3cf7..db7db4b61318 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 45f999eb23c2..e8a0a9955ad5 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 00360c44d610..8d0526978ed9 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 55b2b6f04358..8a4a41e4d68a 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 8936c8d84ecf..766657d12a15 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::() 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 8f3acae71391..42d2a9acdc7b 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 e0cbd2a216db..8df40cabaaa8 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 780edd2149fe..7d21020da647 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:: as *const () < id:: as *const () | = note: see issue #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 1294cc99bf73..01bbe4bc9b96 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 cae5163f0df9..8eee87af8e1b 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 aa42772f12d8..70ce9b2d6a08 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 6fcfe3ed28cc..4f2d92ba3cde 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 01d24a620814..adb5747c4240 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 9a3d5716e001..1a47b82a7d3f 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 95e5f2a8282c..27d00ad04425 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 a6edbf9321b9..c1d7b75af88c 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 2fe84245b3ef..4cc2b7137410 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 d23513ed7ffb..3c0408cbedf7 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 1597120fb5ca..0393316f166b 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 b23796db4f11..ef754b23ff06 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 67b2e90db750..fabebdb1a774 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 efe4fd22e547..18bdde45e2c9 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::::VALUE, GetVariantCount::::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 af59729d438d..e99ce078c112 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 d0dbb21cee01..0f965e1ac3f1 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 1bcc0eb37877..46b380d0f74f 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 c038fc622d46..9b7cd97be224 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 af0f77c6767b..7ad53800ad75 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 342d94ed31c8..fb5cbe0ed898 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 3845068d8411..bfaccf1db1ca 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 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 1e0652722ff2..ea6a8b8ee4a5 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 cf3fd88d0342..51364b01a2d3 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 b129aef3452e..3303a7842653 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 46408f6748d9..e923d95b7550 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 = >::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 407f5d8cb113..5229f1e50cd4 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 4f60b8820691..5c415b5bac18 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 = 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 45ed88b1bb07..833e2745838f 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 6317cd882678..e9643f02840c 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 3ed96701ab0a..39298842a33e 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 c8770c8d76ad..c38e2d44d899 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 57836f7966df..cc893896ecf5 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 5acdcdd95e8e..f4abaecac5e1 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 fe9d0f6e6ed2..acf38d00ec64 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 6860cee4184f..ef9f6345691b 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 b6a1725076bc..db298246e7cf 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 32c25be21735..05e0eeee1332 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 86a669c433df..976cf7bd79eb 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 9eb123d0b01b..a107c4a5c6db 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 82f782fab7f5..9aef78505c08 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 = &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 d592b5aeef5e..3bbb685a6781 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 d592b5aeef5e..3bbb685a6781 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 60ce64d2a1e0..0046005c74f0 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 5f70391eec24..323c49b1d1ba 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 8db75dd63cf2..3d0de233569c 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 5cdcea232310..3d5b012d42f3 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 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 91f9dbd8d0b9..be84608acf78 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 799b5ec8dd9f..6bfa06d86d11 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 4e8470173a10..6bc7e7203aa7 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 f6a651c5e663..bb8f606edf8e 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 c92824a0d1a1..c6dd11ee5db9 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 b75f99a720f6..4b649bf43ed3 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 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 128087f1e375..ff1e28bf9611 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 d583d3d5ea0a..1c4a6b0c3553 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 ad3183e7612b..d31b4eb2b3c8 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 ed58debe2b4c..77e8bb1f92ee 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 fbbedac5775a..b37c27015fb2 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) {} | ^^^^ 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 028523978f9b..aa6e423c7604 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 db0c3c19b581..f9e23e45b443 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 b93ac65f5e7d..b93f6a9a6104 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 388e10fd65e4..928c16f57a2e 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 5e7bd9d8bbfb..c5342ee22e62 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 3db090346cde..7a3b7f2b04c3 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 a9a0d6296065..11dc57bcf467 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 22c83e9a3d5a..a61689a0df51 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 bb9f189fa7c6..199ecf4ca6aa 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 47632d083ea3..347532fb7193 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 3ae50b5aff28..8a23ad17b8b3 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 0ab3c1fbabc5..ca8e43d8a26d 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 b1a258f4f2ca..249a99e9b85c 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 3488b04f2267..c7860fde2a9f 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 ddb3bf66214f..9e7b330d79de 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 fb80f29d10d8..100993bd33cf 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 4c8694e67869..8811faf2fade 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 f1a8a8ed7111..a97cc6190fd9 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 e33310d12d9e..eb8b78df6c99 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 586f53df8f26..e23d653d0d44 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 cd607904f5a6..8ef54298431f 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) { | ^^^^^ 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 cd607904f5a6..8ef54298431f 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) { | ^^^^^ 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 54cf42e78d3b..c0917c7225ba 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 8f5949533e2c..737d9afdd79a 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 9badc1dc291e..da2ec272f9ff 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 8a5b968a5617..436f0901a977 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 1942f266e6cc..c4c3be77ac2b 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 4ff97281d7b4..7233f47884b7 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 7afcd83403eb..d5748b053375 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 b2f839a65db0..b9d4708bb8d8 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 17d58325e986..b56283cab669 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 e60a95316228..62ac02653112 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 7b840b52628f..47131a96bf43 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 a36f4f02265b..3dc89dabde6d 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 96618570d8fb..511562618d56 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 4f5af106613f..b670de39f6db 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` -error: aborting due to 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 5bd4ea97e9cd..d6f20b1f8e9f 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 56eb6ad429af..c7dea801acfb 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 79d1713934b3..ae944387f57a 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 { } = 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 57eca211ed10..90ebe2779391 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 31b18b2df984..dad93cfbba4c 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 3b66704d6131..e8be9b0b9135 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 03cb5015ab0b..8645b4ebccf5 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 c7cc31435204..f2d8f07b04e5 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 f5e4f83473df..bc56b9904f5a 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 d5991bcf5693..06aad9616cb7 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 d5991bcf5693..06aad9616cb7 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 cdc268cff992..f26b43aa3ec7 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 554ff455a207..e11de2452899 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 141664c10922..d78ca20f10b4 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 a73e5605271b..7d411c00445c 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 f499ff85e5da..1723b7bbd053 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 438ce3349d25..81cc608b5ebe 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 b56eedeb80d1..ca827beda059 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 24178faf8de7..48c763c50e3b 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 1297e496bcb3..2e5e574fb6c7 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 b5b79ed3771c..e3cbded339d7 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 4e60368c387c..05b555917299 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 a0262f4c1e59..40485027a660 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 b53c0cda8de4..7d6415fef83c 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 7f4f78cebc91..e9b757b6bae7 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 9f17c76c2ec6..6cbcb455f87e 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 8d062491c6a7..116245aa3cbf 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 31ab589cf385..2c8d9431646d 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 b5580c02f38f..b683a8b89441 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 fbe7e3f8479d..305a92752716 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 639f4d542547..b636404ad9ed 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 7ff6851f6555..3f6c39bf9396 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 346cbec90a94..eaeffaeb8495 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 4b39eeb09ee8..4a725e260dea 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 f3043abcadd2..2f816e1c85b2 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 4844b6359240..359b61528e18 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 9cac7f10780f..1ddb4ec3f642 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 1a9ff9832557..c9edc89e1bc5 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 8205657bb710..7db13e971114 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 af510181df7d..36eeb89bde18 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 f7c371d7d05a..126d10535406 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 311edade0f3d..ae973228cacb 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 043aa954bfa1..85e26c84fa7a 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 26d31b6613fe..f9a654b2df79 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 3155a023ce8a..0a5fbe286587 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 1a06aee5235a..96ef59ca9631 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 377728e8a7f6..7c75ecb6432e 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 e00e990da2a5..429e7e06f5d9 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 959d0b964040..a46133834c6a 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 e3b17431f89a..d0b14ef94c17 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 d1631732a34f..f69451ac793e 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 ab6c6951fc63..d7fc3da46e0e 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 865ecad0e8e6..ea3920f406ce 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 746c1d5d21fd..3f83eb56aaf2 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 8af1776dac87..cf5915173c5e 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 11ea7f9dc31b..de21a903b6ca 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 0a41a3db31ea..3050aeecc0da 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 afeca9fec2b8..0eaca7e23609 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 bb1fab343a3e..151be6901b01 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 e83bbb5b60d7..efb2fb70f5a5 100644 --- a/tests/ui/derives/issue-97343.stderr +++ b/tests/ui/derives/issue-97343.stderr @@ -16,6 +16,6 @@ LL | pub struct 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 01cce2a397ab..384899ea4333 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 b285ee1f3048..b0231d91b431 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 7f7e69c5d5da..e5dfcdf6431a 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 c1b8b32071ce..31ec3fe366f4 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>, ()>>, ()>>, ()>>` to `Box<(dyn Future + '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 393dcf2b8284..eaa968410806 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 16c17526809d..f3bf4f97942c 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 bf277362dbab..8f200e15c64d 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 5dbb9ce45ee9..a7d5c0bfb941 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 1e5ff9398321..da3d8d318922 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 c4ff0e16890b..872c5ae3b764 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 ea4e1ff52a9e..3093b66fe9d8 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 6c8d9afc73b2..2aa4fc18c3d6 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 97a64e603b76..561f9e613fe2 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 e296d48893cd..519ba8a1f5cc 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 21f02e3a73ba..82e3b709f70d 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 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 fc4aa8ef7d89..e00846da77be 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 549c7caa7205..de57f7044bff 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 f9395ae85bc2..d30754dcf10d 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 ce867621daaf..5d07d3a22d50 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 d76b5f72e30c..071c9614f13b 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::::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 b69fcd5d32a6..9cbce93c8e00 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); > > -error: aborting due to 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 2d50c09645d7..6ac0bf21e4ac 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); > > -error: aborting due to 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 1f18ea8923bd..c727a565dbe3 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 9f82d4c44cf0..70aa3c32bfbf 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 4f216568979a..733af860f58e 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 dc1bdfaaed56..a07d83b31db1 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 790ad54a5478..a0392113ab15 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 5b32b5a782c0..1d92f7742c17 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 38ab3c54d01b..57309172194f 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 6f1ed3554382..d9f69eb47d24 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 589b2c378492..92cbc03e0dd7 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 43b7b1894e2a..a1e0b1f1ba4f 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 0bde5783b8cc..ba9020460cea 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 70e49566ac0d..bff57a63deb1 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() { } | ^^^^ 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 71855cf1e20f..dc4189ed9ab6 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 730836a40c26..2ca6436bb999 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 8976341b1ad9..2cacd52b94ef 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 64189bee43f6..882c8652520b 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 596ad4bf784b..45c7a8bb475a 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 e32a4dd44114..837904cbae07 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 f5b5a4cccad2..614f9b9cb5d2 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::(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 dca792315176..d5ea3626e81c 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 1492670dc633..f251ad59a587 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 a2f30d82ec38..8a8fe05ec192 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 fbd1ba085913..a4b322106dfc 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> { | ^^^^^^^^^^^^^^^^ 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 0409ffa02b1a..229514c6feef 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 ffec9306b777..9d5c500f8cc5 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 7d48e9fdcee3..7828aaf23fb6 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 3e39d15f9b0c..8f4d301b5cac 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -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 dbb743544713..4ef7aa61db7a 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -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 bf6d70e7d375..82bc7bc08220 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 27a15170bddb..9d2436f058cd 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 ec81c2ea646f..61fef42fdd26 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 { | ^^^^^^^^^^^^^^^^^^ -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 d613e30b5ea5..886b05e347c9 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 3d9685db683f..9c13b6dc258d 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 19325d6ed440..a6ebf158a075 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 da5088b27b41..9ecc4841dce5 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 6c9e2971c6d6..bca22036fb81 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 b22850814109..c7e9854340f0 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 98db79591152..1b0f9738ab09 100644 --- a/tests/ui/dst/dst-bad-deep.stderr +++ b/tests/ui/dst/dst-bad-deep.stderr @@ -12,6 +12,6 @@ LL | struct Fat { | ^^^ = 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 240553a675bf..266eb228046a 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 933ed5e89e58..03ebc9d6e7a9 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 b132eae4b88d..091c3051e7c0 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 6300b4908d19..9417f8817a87 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 1407a4883e16..4c5f1e7867f5 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 558f868a0c62..74c296e33a6f 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 6692a63dce8f..2be68132787c 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 cd5147c0e153..23f74ef75092 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 8d6a79e12d9e..67eb0bc71a92 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 ba723b38bfad..eff19c09062f 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 f3ef0bcf3a05..413d8b6f8a4d 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 6d078dfbd205..592640a884c9 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 0bb764d712e2..0b194cb8364c 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 | ::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 42fa4fd6f00c..d3ee0d3e550e 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 42fa4fd6f00c..d3ee0d3e550e 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 ba42f619a546..f291b1e2ca3d 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: &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 ba42f619a546..f291b1e2ca3d 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: &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 e60b5c56ff04..b402403ee6fa 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 588e6d97e5ca..b198c5245dea 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 e039bb6f1c82..a9f4a0545192 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 342e71c3a3a9..d8fe25b84bd3 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 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 626b6cd1b7f0..da5afa2d5784 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 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 49706fae19e2..641404aa09e2 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 66e1b9a092c3..06c7bcc57482 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 50aa79f5c0f9..7e2cf661369b 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 = x; = note: expected struct `Box` found struct `Box` -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 b982be451967..b50117c1efb4 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 f6444a60a465..b3274580afe0 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 a7a40c801866..bdf77da713a0 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 8c68dec1df7e..8a65fea11c95 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 | ::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 3f38e6f8e803..606843361f87 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 e7f760e49bcc..4776478b9766 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 e4bdd28213ea..83c648e54aa1 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 570bbac2b21f..c66ccf1ba78a 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 69f275746bdc..6bfc06ad7996 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 612dd17e71ef..3d8b3f633ce8 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 b9afa0133cac..663843ad7bc7 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 e0537ff6faaf..f852a223b425 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 c74c307c492f..e323b8ba7ead 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 7cc8d8fe9229..07a1d9b45c76 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 adcf3670d1d7..9fbcbc3ca9dc 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 5d552e4c4084..cdf3ff83cc38 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 a488e484b2bf..0104a4355384 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 8fadd0e19b39..783e9345acf6 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 fabb6ffb02f7..1e7d82a73bc9 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 9d8b40dc3c9b..6f34015a2cd5 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 3c68933101c8..ce4a94670a78 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 8cee74696295..3b718c6465bd 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 38cfd13b9b88..054bd25a400a 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 fa95ca9c18a1..e81562df04f5 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 2cb159ee2910..01d83e6ded3d 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::(), | = 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 15cd6d30364b..39f0d086ccbd 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 d12be539f7c1..381f24d351e9 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) | ++++ + -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 538898c2f2a6..0293acd6201b 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 be3d7c64e28b..03c722a68b4c 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 49a01abcbd69..9c0dd8f3dd8d 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 7e8453c61f62..216dbda5dd7a 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 b56d599a7866..fa72db6aaef9 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 577c49032d79..49bb73e7ba86 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 e829bac196f7..cc4e18f76d01 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 ced478d65eae..17e2caa866bb 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 4692b66413df..4be37e2e4549 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 dc22053a6389..b07c8bdb700f 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 ec1ce47b2ce7..9d892a3e0985 100644 --- a/tests/ui/error-codes/E0015.stderr +++ b/tests/ui/error-codes/E0015.stderr @@ -6,6 +6,6 @@ LL | const FOO: Option = 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 dfec6d0276a5..03347538a7ac 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 3d460490eb3f..a496a7bdec72 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 031481812d0b..4d0dfbbf1795 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 b89b2e7d11e8..6b7d19f7b227 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 f7250b39d3f9..d596553dc531 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 9435cb204bdd..36200d2b86af 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 1aeca2916787..4e9378dfe1dc 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 31bc6719a562..303c29344281 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 ab2e780ee624..b091ad21720f 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 da6f221881ce..48b8efcf8a29 100644 --- a/tests/ui/error-codes/E0034.stderr +++ b/tests/ui/error-codes/E0034.stderr @@ -21,6 +21,6 @@ LL | ::foo() LL | ::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 3773d6f5234b..99130396e028 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 839be79d28d2..00cccb07c0f5 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 e889c167b98d..e38959fda068 100644 --- a/tests/ui/error-codes/E0044.stderr +++ b/tests/ui/error-codes/E0044.stderr @@ -6,6 +6,6 @@ LL | fn sqrt(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 fcc613b11b8d..25b2f2654da1 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 0a4adabbaf6d..be35242ad725 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 a52c90962355..5cdc8b994699 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 4f6abb22ab2f..a7591d2b04be 100644 --- a/tests/ui/error-codes/E0059.stderr +++ b/tests/ui/error-codes/E0059.stderr @@ -7,6 +7,6 @@ LL | fn foo>(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 934a18d896dc..88c1f1bbb2a5 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 a3e14099507c..87c1c595e016 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 ff9bbe01dd52..20ff8c258a00 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 7bd4ddaf26be..bbd49f43b20d 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 3f927726a030..43e9971e3095 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 7d4ff8798168..ea3bbf094976 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 9a84b2ec4069..aae4b3f2c292 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 e1bda22b8d19..f1fbe6c2532b 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 2d590a8e1d70..4ff2e6f077d2 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 cb0305593a7b..387e0c55d4d2 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 531cd4c784d3..1bad5bd950ec 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() -> 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 8f4cb86de99a..ab0d4aac7430 100644 --- a/tests/ui/error-codes/E0109.stderr +++ b/tests/ui/error-codes/E0109.stderr @@ -12,6 +12,6 @@ LL - type X = u32; 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 4ce2a0a410ce..2f51329ba732 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 8a0276867608..bf215435ba6a 100644 --- a/tests/ui/error-codes/E0116.stderr +++ b/tests/ui/error-codes/E0116.stderr @@ -6,6 +6,6 @@ LL | impl Vec {} | = 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 442f8a4f870f..0d837aa59ff7 100644 --- a/tests/ui/error-codes/E0118.stderr +++ b/tests/ui/error-codes/E0118.stderr @@ -6,6 +6,6 @@ LL | impl 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 e08a2c7fcbbd..838dba081b9e 100644 --- a/tests/ui/error-codes/E0119.stderr +++ b/tests/ui/error-codes/E0119.stderr @@ -7,6 +7,6 @@ LL | impl 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 75778f1f94a1..aef777ad0607 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 73819a89d753..f33495806e14 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 eb66d46936a8..c1ccb4c9e744 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 { | ^ 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 a45571f40a14..a31517218b44 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 4467e19e95d2..3a485cdf3fdf 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() { | ^^^ `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 d4ddc07b5211..b1990afa3ae1 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 b11d5e2c2fc7..f8703ef06335 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 f1d7aba2aa3b..fd4d42bcb8b6 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 fa8c39427323..04877ab4082c 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 29f7e4ad683d..816ba2d569b6 100644 --- a/tests/ui/error-codes/E0152.stderr +++ b/tests/ui/error-codes/E0152.stderr @@ -8,6 +8,6 @@ LL | struct Foo(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 ae82e6702e60..d80de66b2473 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 5a80d6ec31aa..1ed5b0a8f07f 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 52f1f30a4087..625c6685a614 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 8a99c0688e30..40d6ad3f2bdb 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 8971d61fc758..59b210927deb 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 57eda4785a9f..63974fd6cbbb 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` -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 f2c908eea0bb..25fc1a3b79f4 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(&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 6eaa1750ee35..b88064b7f90b 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 35e1042649ef..c06777396e87 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 bb2efefb427b..65b4f5364c29 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 68c308b15cc0..a61a18d170bf 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 c70a2d4f3d1f..fe8353deed11 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 60d8d7bfe983..d19f2e33ac9b 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 5ef51ed86926..01d7c4185441 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 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 2c7072a7e762..77b6ceae4dce 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 e0179aac27fb..76b11f30996e 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 1299ba5f50c1..e985a4c9bf0d 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: `::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 26de5b4c4001..c77a2e98af70 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 46793314bf9f..e981fb91ce89 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(x: &>::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 2722dfe5e054..efbb9ec96dee 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 8f21a0aaba56..4ee36b70fe51 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 b098f8e1a7f4..d89497b2804b 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 352c5ba5be09..e5f908217e13 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 06cbc5b4fb5f..6e086268fc6d 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 2d3305bd15b0..35698c653590 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 ad90b7171266..092db22ed5e1 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 e3f9aea296a2..dcf57d8e3bcc 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 e8e35a12cbb4..14a4ffbe3166 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 1f8657373efe..81f9005d6e6d 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 6422e8a9490e..8d03103dafc3 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 1e2f4383459e..0e456eb0d500 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) where 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 E0271`. diff --git a/tests/ui/error-codes/E0275.stderr b/tests/ui/error-codes/E0275.stderr index c702c3790a7c..b50754083406 100644 --- a/tests/ui/error-codes/E0275.stderr +++ b/tests/ui/error-codes/E0275.stderr @@ -13,6 +13,6 @@ LL | impl Foo for T where Bar: Foo {} = note: 126 redundant requirements hidden = note: required for `Bar` 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 1013f041bbe3..eb004370a1c6 100644 --- a/tests/ui/error-codes/E0276.stderr +++ b/tests/ui/error-codes/E0276.stderr @@ -7,6 +7,6 @@ LL | fn foo(x: T); LL | fn foo(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 a2abf37931a4..9a262f755907 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() { } | ^^^^ 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 0d4782935df4..6cdfaa04f4a2 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 58332454a375..295e84803497 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 293028f5f68b..3bfe8a668332 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` -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 3a8a81a73a6c..b14977917973 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 39c067637379..9f33220a591a 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 141abed6032e..bc6c5a632a1a 100644 --- a/tests/ui/error-codes/E0308.stderr +++ b/tests/ui/error-codes/E0308.stderr @@ -7,6 +7,6 @@ LL | fn size_of(); = 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 96546b83f2f9..bac18596f3e5 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 70e6baf69d3f..1143c383414d 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 Unsize 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 5bfcf1394d9f..d6eb9d6c3833 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 7fb622ee80bb..7bcd99b95786 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 49ec0bce4416..148fa1348ab6 100644 --- a/tests/ui/error-codes/E0374.stderr +++ b/tests/ui/error-codes/E0374.stderr @@ -7,6 +7,6 @@ LL | | where T: CoerceUnsized {} | = 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 a68b3af5aaf7..0a5e4128ae9d 100644 --- a/tests/ui/error-codes/E0375.stderr +++ b/tests/ui/error-codes/E0375.stderr @@ -7,6 +7,6 @@ LL | impl CoerceUnsized> for Foo {} = 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 e91efb045c15..46668e05a42f 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 CoerceUnsized for Foo {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -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 9cb11e5a3d3a..5d710d8e1529 100644 --- a/tests/ui/error-codes/E0377.stderr +++ b/tests/ui/error-codes/E0377.stderr @@ -6,6 +6,6 @@ LL | impl CoerceUnsized> for Foo where T: CoerceUnsized {} | = 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 e4001856c388..156bff7f0223 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 622402999c34..ecbfd5584d5a 100644 --- a/tests/ui/error-codes/E0392.stderr +++ b/tests/ui/error-codes/E0392.stderr @@ -7,6 +7,6 @@ LL | enum Foo { 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 d9f70b729301..4083fa23e87a 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 e77b2ce9a229..2f8ea7993f72 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 d76a58a7c80d..02f255b7e462 100644 --- a/tests/ui/error-codes/E0403.stderr +++ b/tests/ui/error-codes/E0403.stderr @@ -6,6 +6,6 @@ LL | fn foo(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 a22afe6f3e8c..1fb115c9e999 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 6f6d1ff6a8f4..889668f58927 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 132a9432254f..45ac480061f6 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 4c99f9fcbf1d..16da10348a28 100644 --- a/tests/ui/error-codes/E0411.stderr +++ b/tests/ui/error-codes/E0411.stderr @@ -6,6 +6,6 @@ LL | fn main() { LL | ::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 7bdaa1807307..7c1172642faf 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 c2b8fdc7c558..77e5752de817 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 78acac5c6617..643b99087019 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 9ef4608da7da..db78dc3f7abe 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 035f2eb86b90..3e03030dfc96 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 205bcf342f1a..b5bb84e2e68f 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 08b99232ee22..d2d9ba209f74 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 adfd2d923c78..f77c62bec681 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 ed9536f164ef..473e82f86343 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 265d8885c8df..1ac8c3ebc4d4 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 14508ccbc9a7..db9b087f5fd8 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 fc08fade91ce..68d6ddba2a10 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 217b164036f8..b011fa40e1eb 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 853f0c3c2399..701c007afe3a 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 b9a506fee830..e16982542cfa 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 8f0dd25e0309..21c1a50bf849 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 43e27965ffc5..18f20d79385e 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 574270f94a67..edb0b1cf41e1 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 ec650085a2b9..6ecde0e14e5e 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 80ca2b1fbdb5..2d60aee77f84 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 d56baf722720..03f2bad6cb5b 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 cade6d71852f..88d914c0e773 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 275abb23f53a..f1469cdc59bc 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 20e16a538106..c8a48961cb3b 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 1a85e0317053..250680d2c1c5 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 17ad7c611f82..2cc2885f7757 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 089939516228..767fedfccbfb 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 208ba30729f8..1153b1d09c73 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 df2d3b0d311c..4c864e241446 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 c00d9142e750..59843a5491ab 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 d797b10d5a65..59eb19d2ee52 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 3fecce542ce9..eb8ce8b17a4b 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 5243b7caf225..62e70a4668d1 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 e24fc4aaa70f..4fbd268134f2 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 06658a49b83a..83319203023f 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 0a8a41598da9..66359cbacc84 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 8e3eb2159c29..c6e65b55e2b3 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 a2e6288b21be..80d8412a5206 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 21615f954c36..94c83d36e221 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 96b22bb22638..b3e25a965259 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 c312144132d3..125b60bc9142 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 eeccadccc636..0cd276a3cc77 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 23f9cd7ce2db..6983de7ab69c 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 63ee1cd78201..59317780f417 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 bb5ce478ae1a..934bc41cce28 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 1283a9c5ef65..806eed2a632f 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 097871bd3190..42199351c3da 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 6ed90c0ae4ff..68f4a37dcff3 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 36619f8dee4c..e0f59ec84682 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 6707f2864f23..cad61dde4756 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 53c82fb416b8..f0464cc0b033 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 0bbf9a608034..f562e358cba1 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 f4d96f4e45a5..e010cda83ff9 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 3f9aebcc8aea..9f1092d88cf3 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 82e3481b65a5..d3206112bd06 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 a1fb58f483f6..5c1c71d39f71 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 95ac4510ca88..a76f2354da65 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 a687f575615d..41a4a8f7dbba 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 ee902584f56d..1ac1bbd89a76 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 68da03928b78..e91f74d6b3fd 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 a0fe02c1c4d9..835ababf4495 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 f23f9977ba0b..da7be147819c 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 d2a11e906274..c889765be54e 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 a2966eea44c0..4263368ff421 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 598117c2b605..ae7c2ce9a132 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 c12e1a3a6436..13446a475a05 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 da349ed2fde3..73eb64ab468d 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 65152b2b74dd..5bc8903624ce 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 b9edeb8346bd..2d96926a230f 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 8466dfe3848c..c59776b211fd 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 23a8ea8a8c98..b2bc2c92d368 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 069401b3f182..7f8d7ae70222 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 9d1ab967127a..4b444e5a3972 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 1a65825c7b6c..e995e5313951 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 8d423484528a..686394b6d225 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 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 b0c73c636c62..dbb72bb67599 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 30378dd16745..9a3db136d23c 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 067e8c57cd63..5e996ac35551 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 9450c61c27be..e1384effe37a 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 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 42647e5c6a1b..7eb24c493bf5 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 7c6a119a0961..a01aa98b914c 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 654073eec260..c0519c60e422 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 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 1b2d64282e1e..86737742f749 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 { - impl LolFrom for U where T: LolInto; -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 9b3345c23bb2..b0918a3d6497 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 Into for GenX { - impl Into for T where U: From; -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 97b570bc7aca..be3e4aea51a1 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 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 99367e808419..869b11b1909f 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 From for MyError { = note: conflicting implementation in crate `core`: - impl From 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 1da7b33be9dc..fb61eba15096 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 4dd9848cf07b..23c1697b9b20 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 637eb27db01e..658584e2ff4b 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) {} | ^^^^ 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 5aaf9741360e..61496e5b57b3 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 51e3b776cb2c..7aa66be0d097 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 51e3b776cb2c..7aa66be0d097 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 004f10b4e431..46d33d26052c 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 004f10b4e431..46d33d26052c 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 98fe328193ce..0badea6e27bf 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 839c20509fe7..81ed683737c7 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 9b67f08af3ae..07747e2cc9cd 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 f2e0b73b6c5e..6f40f3998a98 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 5fa42fcf1911..d2d69ce6daf7 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 8a2890886a15..ca0eced267d6 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 47dac39a9ae8..afc26757c461 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 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 d2bba88211ea..0e86a24f31b7 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 b40a0f479d31..285f5c4a6f22 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 74ed0ed0ae6b..1be43a20105f 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 2d1ee04ce09a..98bde827a72a 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 317faf7c619f..4eaa03934967 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 612fe77642ce..c761d0b85531 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 f70b32117433..1264d9693425 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 d4640fba96cf..8af7030172cb 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 e8b34121b5f8..b1607bbacc92 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 e44ec5ca93ce..a7ed9f5880b6 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 f3aa83fd5080..8891e823e4af 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 258e2b347fba..9db1c0be7468 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 25e218c63f33..ef5e654d0543 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 70b85932c233..36d485676c21 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 e7da4e046ab8..9b6e32bc95f2 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 e3dce000530a..5198818f89cc 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 342a9f7096e7..85ed442e2fea 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 47cf810b70d7..c0fd5d57251f 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 5088fb1c4d2e..0aaca5ee253e 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 6446c53236ca..171079287f0b 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 57878721683a..23b9b2fd94b2 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 9dfc10effcf1..209f5d4dadc5 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 a296751994ea..4c2c3d6e0a84 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 5f1477955211..43f6e56ab0e7 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 079c9cecd8ed..dc34490b39a0 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 5b7a720736a1..e4d767f0e864 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 846102670a83..fd4e67e893e6 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 18dfddc46bd3..8a3262fbcc7b 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 75836f7eca19..3547f9b3ff61 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() {} | ^^^^ 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 3e6dc5cefadf..ea4e51862f31 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 88be1e5dd3da..42448d9e9246 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() -> 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 463cee83169d..1c08aa1717f4 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) 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 aff8bf7927dd..9376ac35e215 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 c696c3598301..8857f379ad18 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 5f78775f5409..25348b64002f 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 65067942b85c..d40f905b6659 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 272751916f5b..d4fec1b45c9d 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 a34e60b6448f..c7aeaac75dd6 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 af8f54291ff4..39fec3e2517b 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 9caf48dd1386..ebd03e91c228 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 ff5855290d40..15398c8505f0 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 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 1757befec35c..3cc7b100db2f 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 13b9b84f0be4..e6eeca2e098a 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; = 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 f414eb463dfb..1f22c8c58513 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 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 6e276f7bccd6..66a1c1be3f4e 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 4621bc0b30e5..c2d29db68669 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 1232d13a457a..c0ab67025b26 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 3c1a4bfc7d2c..cb6cf4699fd8 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 4a859430e044..9db088475a16 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 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 05e66acb556a..eeabf7a5b0c8 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 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 9edad6153273..2ebaf40dcf6e 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 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 6563fbcba2e4..a5f92b44c41d 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>() {} = note: see issue #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 601ec46a4439..da15f698b75c 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 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 3bc7848f66dd..6601d4cb417a 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 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 7b3af8d994f6..a439f297ba33 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 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 592768a42031..bd43e190513f 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 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 af59c7141477..3400808bb728 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 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 79aba7945f6a..22f9af8390d4 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 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 8088585da8dd..b53fc3acdbcc 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 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 b10a15088818..04b206499405 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 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 2cbde893af9b..f0b8fd1f373a 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 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 9d04aef8621e..eadc4ddcb286 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 4b3ee4c19cec..69b196335dae 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 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 3c149d30d82b..f0f67adcca58 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 800caf252395..94b609f05262 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 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 ce06ce916a75..e727b69ffceb 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: Rc`, `self: Arc`, or `self: Pin